This article explains what API gateways are, why they are essential in microservice architectures, and how they address cross‑cutting concerns such as authentication, transport security, load balancing, request routing, dependency resolution, and data transformation, illustrated with a Node.js example.
The article examines Nacos' evolution from its Alibaba origins, outlines the performance and resource problems of the 1.x architecture, and details how the 2.x version’s long‑connection gRPC model, improved reliability, and compatibility enhancements address those issues while introducing new complexities.
This article explains how Zhuanzhuan’s service management platform implements comprehensive service governance—including registration, discovery, configuration, monitoring, authentication, rate limiting, and alerting—to support micro‑service architectures and improve reliability, scalability, and operational efficiency.
Service mesh, likened to TCP for microservices, abstracts and standardizes service‑to‑service networking—handling registration, discovery, load balancing, resilience, security, and observability—so business teams can focus on code, with Tencent’s Polaris bridging legacy L5 and Istio demonstrating practical deployment on TKE.
This article walks through the journey of transforming a simple online supermarket from a monolithic web application to a fully fledged microservice architecture, covering the motivations, common pitfalls, service decomposition, monitoring, tracing, logging, gateway, service discovery, circuit breaking, testing strategies, and the role of service mesh.
This guide explains how to combine Spring Cloud's service registration and discovery with RSocket, covering naming conventions, Consul setup, RSocket service implementation, client load‑balancing, broker mode support, and developer‑experience enhancements for robust backend communication.
The article traces the evolution of software architecture—from monolithic applications through vertical splitting, distributed services, and finally microservices—detailing their advantages, drawbacks, and the essential technology stack such as service discovery, API gateways, authentication, logging, containerization, orchestration, and CI/CD, while providing practical examples and references.
This article provides a concise yet comprehensive overview of etcd, covering its background, core features, common application scenarios such as key‑value storage, service discovery, messaging and distributed locking, and detailed step‑by‑step installation methods for various platforms.
This article explains how Dubbo integrates with Kubernetes to provide application‑level service discovery using a metadata service and revision mechanism, detailing both API‑client and DNS‑client implementations, their workflows, advantages, drawbacks, and future directions toward cloud‑native adoption.
This article explains Dubbo’s internal architecture, covering service registration and discovery with Zookeeper, RPC invocation details including load balancing, routing, and fault‑tolerance strategies, as well as its network protocol and thread‑dispatch mechanisms, providing practical insights for backend developers.
This article provides a comprehensive overview of Kubernetes, covering its core components, container deployment and scaling, service discovery methods, shared pod resources, common CNI plugins, multi-layer load balancing, isolation dimensions, network model principles, and IP address classifications for large-scale cloud-native deployments.
This article explains how to build a microservice‑based PaaS platform using Spring Cloud Netflix components, Docker containers, Eureka for service registration, Zuul as a gateway, Hystrix for fault tolerance, and a dynamic configuration center to achieve agile development and continuous integration.
This article compares three Nacos cluster deployment patterns—direct connection, VIP (Virtual IP), and address server—detailing their configurations, advantages, and trade‑offs for high availability, scalability, and operational complexity in production environments.
This article provides a concise, step‑by‑step overview of Kubernetes, covering its master‑node architecture, core components, deployment workflow, pod fundamentals, service discovery, networking models, and external access methods for modern cloud‑native applications.
This article provides a comprehensive overview of microservice architecture, covering the definition, typical components, prerequisites for service‑orientation, methods for publishing and referencing services, registration and discovery mechanisms, remote communication, and detailed strategies for ensuring stability of registration centers, service consumers, and service providers.
This article provides a comprehensive overview of microservice architecture, covering its definition, history, differences from monolithic development, core characteristics, comparison with SOA, practical implementation steps, communication methods, design patterns, advantages, challenges, and recommended reading resources.
This article details Industrial Bank's migration to Dubbo micro‑services, the performance and high‑availability challenges of managing over 20,000 services with Zookeeper, and the concrete optimizations—delayed subscription, multiple‑registry mode, and per‑node registration—that enabled stable, large‑scale service discovery.
The article examines the challenges of exposing numerous backend microservices to clients and proposes using an API gateway to centralize traffic, handle authentication, rate limiting, protocol conversion, service discovery, performance optimization, and operational concerns, while also discussing the shift toward decentralized service‑mesh solutions.
This article introduces Spring Boot as a lightweight Java framework, explains Spring Cloud's microservice components such as Eureka, Zuul, Ribbon, Feign, Hystrix, and Turbine, outlines Spring Cloud Alibaba's features, and describes Nacos as a combined service registry and configuration center for cloud‑native applications.
This tutorial walks through using the Go-Micro microservice framework (v2/Nitro) together with Nacos to register services, discover them, and build a simple Go-based client‑server demo, including all required code snippets and configuration steps.
This article presents a structured approach to mastering microservices, covering the learning pyramid concept, a detailed learning path with resource collection, and an overview of the six essential components—service description, registry, framework, monitoring, tracing, and governance—along with practical tips and visual diagrams.
This guide walks you through installing Nacos via source compilation or Docker, starting it in standalone mode, and using its core OpenAPI endpoints to register, heartbeat, query, and deregister service instances, complete with code snippets and visual screenshots.
This tutorial walks you through creating two Spring Boot microservices, adding Nacos dependencies, configuring discovery, implementing a simple /hello endpoint, and invoking it from a consumer service using RestTemplate and LoadBalancerClient, all with complete code examples.
This article explains how service discovery has progressed from simple centralized proxies to client‑embedded libraries and finally to host‑level independent processes like Service Mesh, detailing each generation, their pros and cons, and how Kubernetes implements discovery and load balancing.
This article explains how Dubbo Spring Cloud bridges Apache Dubbo 3.0 with the Spring Cloud ecosystem, covering version compatibility, service registration and discovery, load balancing, circuit breaking, service introspection, migration strategies, and provides step‑by‑step Maven and YAML configurations with complete code examples for both provider and consumer applications.
This article explains how to construct a reliable, high‑throughput microservice platform using open‑source components such as Consul, an access layer, and token‑based multi‑tenant service discovery, covering architecture, registration, heartbeat handling, performance optimizations, high‑availability strategies, graceful shutdown, and deployment best practices.
This guide explains how to download, build, and run Nacos from source, customize its UI, ensure server‑client version consistency, and modify configuration files, providing step‑by‑step commands and code snippets for Linux, macOS, and Windows environments.
This article outlines why distributed systems are needed, explains how they address cost and high‑availability issues through coordinated nodes, and discusses the new challenges such as service discovery, load balancing, avalanche prevention, monitoring, data sharding, replication, and distributed transactions, while offering practical and theoretical learning paths.
The talk explains how Tencent’s Liu Zhixin built a stable, high‑traffic microservice platform by layering a multi‑tenant, token‑authenticated access service in front of open‑source Consul, aggregating registrations and watches, scaling horizontally, and adding HA features such as circuit‑breakers, caching, graceful shutdown and rolling updates for reliable service discovery.
This article walks through the evolution of an online supermarket from a simple monolithic web application to a fully decomposed microservice architecture, highlighting the challenges of scaling, the need for monitoring, tracing, service discovery, fault tolerance, and the eventual adoption of a service mesh.
This article describes the design and implementation of a PaaS cloud platform based on microservice architecture, covering service access paths, gateway functions with Zuul, service registration with Eureka, fault tolerance using Hystrix, dynamic configuration via Spring Cloud ConfigServer, and Docker container deployment.
This article explains Eureka's role as a Spring Cloud service registry, detailing its server and client components, registration and renewal processes, self‑preservation mechanism, clustering principles, and the complete workflow that enables reliable microservice discovery and high availability.
This guide walks through Prometheus fundamentals, architecture, components, service discovery, Docker-based deployment, exporter integration, Alertmanager configuration, Grafana visualization, PromQL queries, and Consul service discovery, providing a complete end‑to‑end monitoring solution for cloud‑native environments.
This guide explains why Dubbo introduced application‑level service discovery, how it differs from interface‑level registration, and provides step‑by‑step instructions—including Docker‑based Zookeeper setup, source code configuration, and code examples—to enable and test the new feature in Dubbo 2.7.5.
This article introduces Consul, an open‑source service discovery and configuration tool, and provides step‑by‑step instructions for installing the binary, configuring services, using the web UI, managing KV data, integrating with Java, and building a multi‑node Consul cluster.
This article introduces Spring Cloud as a Spring Boot‑based microservice framework, explains the fundamentals of service architecture through an illustrative story, and details essential components such as service registry, discovery, load balancing, circuit breaking, configuration management, messaging bus, and tracing, accompanied by practical code examples.
This article compares Netflix’s Eureka and Apache Zookeeper as service registration solutions, explaining their underlying AP and CP designs, how Eureka’s peer‑to‑peer architecture and self‑preservation mode ensure high availability, and why AP‑oriented registries may be preferable for typical microservice environments.
This article explains what microservices are, how they communicate, compares Spring Cloud with Dubbo, describes the relationship between Spring Boot and Spring Cloud, and discusses circuit breaking, service degradation, advantages, disadvantages, service discovery tools, and typical technology stacks.
This article explains what a service registry is, outlines its essential capabilities such as high availability, horizontal scaling, health checking, routing, and multi‑datacenter support, and compares popular open‑source solutions like Zookeeper and Nacos to help you select the right one for your stack.
Facing frequent service outages as their microservice count grew, MasterTeach migrated from Eureka to Alibaba Nacos, designing a high‑availability Nacos‑Eureka sync solution with consistent‑hash sharding, Zookeeper/Etcd coordination, automated DevOps integration, and extensive fault‑tolerance testing to ensure stable operation of over 660 services.
This article explains how to configure Dubbo for local service calls and test‑environment isolation by using @Reference URL specifications, a user‑home properties file, and Nacos namespace isolation, providing practical steps for backend developers to avoid cross‑instance interference and streamline branch testing.
This article explains the concept of Service Mesh, why it emerged from micro‑service challenges, its evolution, and compares the main open‑source implementations such as Linkerd, Envoy, Istio, and Conduit, helping readers grasp its role in modern cloud‑native architectures.
iQIYI built a Prometheus‑based microservice monitoring platform that uses Spring Boot Actuator, Micrometer, custom QAE collectors, file‑based service discovery, and an Alert‑proxy to gather container, application, and third‑party metrics, define PromQL alert rules, and forward alerts to its unified notification system, illustrating best practices and lessons learned.
This article describes how Dada Group tackled rapid micro‑service growth by designing a language‑agnostic, lightweight service governance and traffic routing engine that uses Consul metadata, configurable routing rules, and link‑based isolation to enable online pressure testing, parallel development, hot‑cold service separation, gray releases, and dynamic rate limiting.
This article provides a comprehensive overview of microservices, covering their definition, independent communication methods, differences between Spring Cloud and Dubbo, the relationship between Spring Boot and Spring Cloud, fault‑tolerance mechanisms like circuit breaking and degradation, advantages and disadvantages, and a comparison of Eureka and Zookeeper for service registration and discovery.
Microservices, introduced in 2012 and popularized by Martin Fowler, decompose applications into small, independent services that communicate via lightweight protocols, enabling modular development, flexible technology choices, independent deployment, and improved scalability, while also introducing challenges such as distributed data consistency, testing complexity, and operational overhead.
This article introduces Spring Cloud as a microservice framework, explains the fundamentals of service architecture, compares SOA and microservices, and walks through essential components such as service registration, discovery, load‑balanced calls, circuit breakers, gateways, configuration management, message bus, and tracing with practical code examples.
This article provides a comprehensive introduction to microservice architecture, covering service decomposition, registration and discovery methods, client‑driven load balancing, rate‑limiting and circuit‑breaking strategies, and the design of a self‑built application delivery platform for cloud‑native environments.
This article examines a decade of Alibaba’s experience with ZooKeeper‑based service discovery, arguing that ZooKeeper’s strong consistency and limited scalability make it unsuitable as a registration center and outlining design principles that favor availability, eventual consistency, and richer health‑check mechanisms.
Meituan’s Naming Service 2.0 replaces the ZooKeeper‑based 1.0 design with a four‑layer, AP‑oriented architecture that leverages a service‑mesh sidecar, sharded KV storage, and a control service layer, delivering eight‑fold throughput gains, sub‑second latency, zero‑downtime migration for most services, and new business capabilities such as traffic isolation, elastic scaling, and data‑driven SLA monitoring.
This guide explains what Consul is, walks through setting up a three‑node Consul cluster, registers services via the HTTP API, and configures Prometheus to discover those services using Consul, including detailed command examples and YAML configuration.
This article introduces Nacos as a cloud-native service discovery and configuration platform, compares its features with Zookeeper, explains the CAP theorem and consistency protocols, details the proprietary Distro protocol, and provides a practical evaluation of its performance and limitations.
This guide walks through setting up Nacos as a service discovery platform for a Spring Cloud microservice architecture, covering dependency inclusion, server installation, configuration of each service’s address, enabling discovery annotations, naming services, and accessing the Nacos dashboard, with full code snippets and troubleshooting tips.
A tech director, inspired by Netflix, forces his team to adopt microservices, encountering Docker, Kubernetes, distributed transactions, tracing, logging, and contract testing, only to face performance complaints, dismissal, and a lesson that microservice architecture isn’t a one‑size‑fits‑all solution.
This article analyzes the limitations of ZooKeeper for service discovery, covering consistency, partition tolerance, scalability, persistence, health‑checking, disaster‑recovery, and operational complexities, and explains why modern registration centers should favor AP designs and richer health‑check mechanisms.
This article introduces Spring Cloud, explains its key components such as service discovery, configuration management, messaging, security, and tracing, shows how they integrate to form a complete micro‑service architecture, and compares Spring Cloud with Dubbo, highlighting their different scopes and communication models.
This article explains Envoy’s service discovery mechanisms—including static, strict DNS, logical DNS, original‑destination, and Service Discovery Service—detailing how they work, their consistency models, and how health‑checking influences routing decisions in production environments.
This comprehensive guide explains what etcd is, its Raft‑based architecture, key terminology, read/write flow, leader election, common scenarios such as service discovery and distributed locking, and provides step‑by‑step instructions for single‑node and multi‑node deployments with practical command examples.
This article explains how Kubernetes provides stable service discovery by using a flat pod network, Service objects with immutable front‑ends and dynamic back‑ends, DNS registration, Endpoints, and kube‑proxy iptables/IPVS rules to route traffic from virtual ClusterIP addresses to healthy pods.
This article provides a comprehensive introduction to Spring Cloud, explaining how it builds on Spring Boot to simplify distributed system development with components for service discovery, configuration management, messaging, monitoring, security, and compares its approach to Dubbo's RPC framework.
A misconfigured Dubbo consumer created both Dubbo and REST invokers, causing thousands of failed REST invoker attempts that filled a synchronized List of ResteasyClient objects, exhausting the old generation heap and triggering OOM, which was fixed by replacing the List with a WeakHashMap‑based client map.
The article explains how YouZan adopted Ctrip’s open‑source Apollo distributed configuration center—detailing its architecture, environment and cluster isolation, security enhancements for SaaS, namespace designs, client polling mechanisms, and planned upgrades such as WebSocket long‑polling and ETCD replacement.
This article introduces Huajiao's open‑source backend services—gokeeper, pepperbus, peppercron, and dashboard—detailing their features, architecture, and step‑by‑step Docker‑based deployment, configuration, and usage with Go code examples for service discovery and distributed cron management.
Learn how to replace manual Nginx upstream configuration with automatic service discovery using Nacos, by either writing Lua scripts with the nginx‑lua‑module or building a Java/Golang agent that fetches instance lists via the Nacos API, updates upstream blocks, and triggers hot reloads.
This article presents Bilibili's exploration of microservice governance, detailing the challenges of service splitting and large‑scale management, the design and evolution of its Go‑based Discovery service discovery framework, advanced load‑balancing algorithms, adaptive rate‑limiting, circuit‑breaking strategies, and future directions for resilient backend systems.
Based on a decade of Alibaba’s production experience, this article analyzes the requirements and design trade‑offs of service‑discovery registries, arguing that ZooKeeper’s strong consistency and coordination focus make it unsuitable as a primary registration center and proposing AP‑oriented, scalable alternatives.
This comprehensive guide explains the benefits of microservices and walks through core building blocks such as RPC, service discovery, configuration management, task scheduling, distributed locking, unified monitoring, caching strategies, message queues, distributed transactions, CAP theory, seckill handling, Docker isolation, and modern CI/CD deployment pipelines.
This guide introduces Huajiao Live’s newly open‑sourced backend components—Gokeeper for centralized configuration and service discovery, Pepperbus for message bus, Peppercron for distributed cron management, and the Dashboard UI—providing repository links, Docker images, installation steps, configuration formats, code examples, and operational details for quick deployment.
This article explains what Dubbo is, its core capabilities such as cluster fault tolerance, remote communication, and service discovery, details default and alternative communication and serialization frameworks, outlines key configuration elements, and provides solutions to frequent deployment and runtime issues.
This article explains Zookeeper's core features—such as its tree‑like directory, persistent and ephemeral nodes, sequential ordering, and watcher mechanism—and demonstrates how these capabilities enable distributed locks and service registration/discovery within microservice architectures.
The article explains why Zookeeper’s CP consistency model and performance characteristics make it unsuitable for high‑availability service registries, advocating an AP‑oriented approach for service discovery in large‑scale systems.
This guide explains why service discovery is essential, details Consul's internal architecture, walks through building a Docker‑based Consul cluster, shows how to register services, query them via HTTP API or DNS, and covers health checks, deregistration, and alternative deployment patterns.
This article introduces the fundamental concepts of microservices, covering their definition, advantages, design principles, core components such as service discovery, gateways, configuration centers, monitoring, circuit breaking, and container orchestration, while also discussing suitable organizational structures and practical implementation details.
This article traces etcd’s evolution from its CoreOS origins, explains its Raft‑based distributed architecture, details its API groups, versioning and watch mechanisms, and showcases typical scenarios such as metadata storage, service discovery, leader election, and distributed coordination in cloud‑native environments.
This guide walks through designing a Java RPC framework from the user's viewpoint, covering interface definition, client stub generation with dynamic proxies, flexible protocol and service discovery layers, server request handling, and key implementation steps, illustrated with diagrams and code snippets.
Nacos 1.1.4 introduces Istio MCP integration, a server‑side upgrade guide, client dependency changes, custom instance ID support, and detailed usage steps, while also highlighting community contribution paths and previewing the upcoming 1.2.0 release with permission control.
This tutorial walks through installing Nacos, using it as a service registry and configuration center with Spring Cloud Alibaba, configuring Maven dependencies, setting up discovery and config modules, demonstrating load balancing, and showing dynamic configuration refresh in a microservices environment.
This guide walks you through installing Consul, registering Spring Boot services, enabling client-side load balancing, using Consul as a configuration center, and leveraging its dynamic refresh capabilities, complete with code snippets and configuration examples for a full cloud-native microservices setup.
This article explains ZeroConf—a set of protocols that enable automatic IP address assignment and service discovery in local networks—by detailing its three core technologies (Link‑Local Address, Multicast DNS, DNS‑SD), their operation, and a practical Avahi‑based implementation with packet captures.
This article explains Docker’s origins, core concepts, and the challenges of container IP volatility, then compares client‑side and server‑side service discovery methods, evaluates DNS, LVS/IPVS, Nginx and HAProxy solutions, and presents practical load‑balancing architectures—including dynamic SLB integration and rolling‑update strategies—for reliable container deployments.
Java’s Service Provider Interface (SPI) is a built‑in discovery mechanism that decouples implementation from usage by letting providers place fully qualified class names in META‑INF/services files, enabling frameworks such as JDBC, logging, and Dubbo to load multiple vendor implementations at runtime via ServiceLoader, though it has limitations like lack of on‑demand loading and concurrency issues.
This article explores best‑practice patterns for microservice communication, covering synchronous and asynchronous protocols, serialization formats, API design, service discovery, versioning, rate limiting, circuit breakers, correlation IDs, distributed consistency, authentication, retries, and economic considerations.
The story follows a tiny PHP application named Phippy, who moves from a lonely shared host into a container, meets the wise Captain Kube, learns about Pods, Replication Controllers, services, volumes, and namespaces, and discovers how Kubernetes orchestrates isolated yet connected workloads, illustrated through a whimsical maritime metaphor.
This article details the two‑year evolution of 58 Group’s container cloud platform, describing its background, overall architecture, network and service‑discovery advancements, operational challenges, and lessons learned from migrating over 90% of the company’s traffic to a Docker‑Kubernetes‑based cloud environment.
This article explains what Spring Cloud is, its advantages for distributed microservices, the meaning of service registration and discovery, the purpose of load balancing, how Hystrix provides fault tolerance and circuit breaking, the role of Netflix Feign, and the function of Spring Cloud Bus for configuration refresh across instances.
This article shares a publicly accessible Nacos server with login credentials, provides client configuration snippets for service discovery and configuration center, lists related Spring Cloud Alibaba tutorials, example repositories, and additional resources for developers to experiment with microservice architectures.
This article explains how Spring Cloud modules formerly backed by Netflix OSS are moving to maintenance mode and shows how to replace them with Consul for service discovery and configuration, use Spring Cloud Gateway as the API gateway, and adopt Spring Cloud LoadBalancer for client‑side load balancing in modern cloud‑native microservices.
This article explains how to transform a traditional monolithic setup into a fully automated, cloud‑native microservice architecture using Docker containerization, Consul for service discovery and configuration, and HAProxy for dynamic DNS‑based routing, detailing the challenges, solutions, and practical configuration examples.
This article explains how to transform a traditional monolithic deployment into a fully automated micro‑services environment by containerizing services, using Consul for dynamic service discovery and configuration, and configuring HAProxy with DNS resolvers to achieve seamless load balancing and zero‑downtime updates.
This article outlines ten key design considerations for building robust microservice architectures, covering API gateways, stateless services, database scaling, caching, service decomposition, orchestration, configuration management, logging, resilience patterns, and comprehensive monitoring to ensure high availability and performance.
This guide explains how to construct a client library for Youzan's customized NSQ, covering workflow configuration, nsqd discovery via nsqlookupd, connection establishment, message publishing and consumption, ordered consumption, and the implementation of message tracing with concrete command syntax and response handling.
This tutorial walks through setting up a Nacos cluster for production, covering MySQL data source initialization, cluster configuration files, local multi‑instance testing, deployment on separate nodes, Nginx reverse‑proxy setup, and common troubleshooting steps.
This article explains how a service registry works in microservice architectures, covering self‑registration and third‑party registration, client‑side and server‑side discovery, and provides practical Node.js code examples and a systemd unit for managing service registration.
This article demonstrates how to use Nacos for service registration and discovery in Spring Cloud and shows three convenient client consumption methods—enhanced RestTemplate, reactive WebClient, and declarative Feign—complete with configuration, code examples, and the underlying load‑balancing mechanism.
The article introduces Nacos 0.8.0, highlighting its three major production features—user login, Prometheus metrics, and namespace isolation—while providing step‑by‑step download links, startup commands for Linux and Windows, and instructions to access the default login console.
This tutorial walks you through installing Nacos, configuring Spring Cloud Alibaba for service registration and discovery, building provider and consumer Spring Boot applications, and testing load‑balanced calls, offering a complete hands‑on guide to cloud‑native microservice integration.
This article explains a practical, simplified microservices architecture that focuses on essential components such as service registry, discovery, load balancing, and API gateways, and provides step‑by‑step guidance on implementation, deployment, and operations to improve development speed, maintainability, and scalability for typical enterprise projects.
This article examines how Eureka, the Spring Cloud service registry, stores its registry in an in‑memory ConcurrentHashMap, uses a 30‑second pull and heartbeat interval, and employs a multi‑level cache to comfortably handle millions of daily requests in large‑scale microservice deployments.
This article explains why service discovery is essential for microservice architectures, dives into Consul’s internal mechanisms—including multi‑datacenter gossip, Raft consensus, and client‑server roles—then provides step‑by‑step Docker deployment, service registration, health‑check configuration, and practical discovery methods via HTTP API and DNS.
This article explains the concept of a simple microservices architecture, outlines essential components such as service registry, discovery, load balancing and API gateway, compares three load‑balancing approaches, and provides concrete implementation guidance using Eureka, Ribbon, Zuul and related DevOps practices.
