Tagged articles
Configuration Center
60 articles · Page 1 of 1
This article deep-dives into Nacos' dual role as service registry and config center, explaining its AP-based Distro protocol, heartbeat mechanisms, gRPC long-polling config push, @RefreshScope internals, deployment essentials, and eight common pitfalls with troubleshooting steps.
@RefreshScopeConfiguration CenterDistro Protocol
0 likes · 24 min read

This chapter summary traces the evolution from monolith to microservices, detailing core components like service discovery, circuit breakers, gateways, and observability, while stressing that adoption must be driven by business complexity and team needs — not service count — and provides a practical checklist for splitting and transformation.
API GatewayCircuit BreakerConfiguration Center
0 likes · 10 min read

This article provides a comprehensive tutorial on Apollo configuration center, covering its core concepts (application, environment, cluster, namespace), client architecture with long-polling and local caching, overall system design with Config/Admin services and Eureka, availability scenarios, hands-on SpringBoot integration with Maven setup, dynamic configuration testing (updates, rollbacks, offline fallback), multi-environment/cluster/namespace usage, and Kubernetes deployment via Docker and YAML manifests.
ApolloConfiguration CenterCtrip
0 likes · 27 min read

This article dissects Nacos configuration center's core mechanisms — long-connection push, local disk caching, and differentiated refresh behaviors — and postmortems four real production incidents: config drift causing instance divergence, large-config push triggering cluster avalanche, K8s IP-based gray release failure, and rollback ineffectiveness due to lost push events and cache pollution. It provides coding standards, enterprise-grade landing specifications, and emergency SOPs.
CachingConfiguration CenterGray Release
0 likes · 15 min read

This article analytically compares Apollo and Nacos—two leading configuration centers for microservices—by examining their design philosophies, setup procedures, core features, real‑time push mechanisms, data models, performance, operational overhead, and community support, ultimately offering guidance on selecting the most suitable solution for different project scenarios.
ApolloConfiguration CenterNacos
0 likes · 25 min read

This article explains why the team replaced Nacos with Ctrip's open‑source Apollo configuration center, outlines Apollo's core concepts, features, and architecture, and provides step‑by‑step instructions for creating projects, testing dynamic updates, exploring environments, clusters, namespaces, and deploying a SpringBoot application on Kubernetes.
ApolloConfiguration CenterJava
0 likes · 28 min read

A misconfigured Nacos registration setting (ephemeral=false) caused a memory‑leaking payment service node to stay in the service registry, leading to repeated requests to a dead instance and a cascade failure of the entire online payment flow.
Configuration CenterEphemeral InstanceNacos
0 likes · 7 min read

This article explains how Nacos continues to provide configuration reads and service calls after its server crashes, details its long‑polling mechanism for dynamic updates, describes where configuration data is stored, compares the CAP trade‑offs for service discovery versus configuration management, and clarifies why Nacos implements both Distro and Raft protocols.
CAP theoremConfiguration CenterDistro Protocol
0 likes · 7 min read

A misconfigured Nacos registration type turned a temporary service instance into a persistent one, causing heartbeat blockage and a cascading failure in the payment chain, illustrating when to use temporary versus persistent instances in service registries and configuration centers.
Configuration CenterNacosService Discovery
0 likes · 9 min read

This tutorial walks through setting up Nacos as a cloud‑native service registry and configuration center, covering installation modes, service registration, discovery, load‑balancing with Spring Cloud, dynamic configuration loading, namespace isolation, and best‑practice patterns for managing microservice environments.
Configuration CenterNacosService Discovery
0 likes · 23 min read

This article explains the inner workings of Nacos' configuration center, detailing the client‑side long‑polling mechanism, the server‑side handling of listener requests, and the key classes and code paths that enable real‑time config updates in microservice environments.
BackendConfiguration CenterJava
0 likes · 13 min read

This guide walks through upgrading a Spring Cloud Gateway by integrating Nacos as a service registry and configuration center, showing how to enable automatic request forwarding, dynamic route loading, and load‑balancing with step‑by‑step code examples and configuration files.
Configuration CenterNacosService Discovery
0 likes · 16 min read

This article walks through using Nacos as a centralized configuration center for Spring Cloud microservices, showing how to create configuration data, set up a Maven client, enable dynamic refresh with @RefreshScope, and manage multi‑environment and multi‑file configurations.
@RefreshScopeConfiguration CenterNacos
0 likes · 16 min read

This article explains why a centralized configuration center is needed for many microservices, introduces Spring Cloud Config, and provides a step‑by‑step tutorial that creates a Git‑backed config server, a client application, and demonstrates dynamic refresh using Spring Boot Actuator.
ActuatorConfiguration CenterSpring Boot
0 likes · 12 min read

This article explains how Nacos’s ConfigService initiates a long‑polling task on the client side, how the client periodically checks for configuration changes, and how the Nacos server processes long‑polling requests, detailing the relevant classes, methods, and code flow.
Configuration CenterJavaLong Polling
0 likes · 14 min read

This article dissects Nacos' configuration center long‑polling mechanism, detailing the client‑side initialization, thread‑pool scheduling, cache handling, and server‑side request processing, while illustrating the flow with code snippets and diagrams to help developers understand real‑time config synchronization.
Configuration CenterJavaLong Polling
0 likes · 15 min read

This article explains the principles and source‑code flow of Nacos configuration center’s long‑polling mechanism, detailing how the client initiates periodic tasks, how the server processes listener requests, and how configuration changes are detected and propagated through various internal classes and threads.
BackendConfiguration CenterJava
0 likes · 10 min read

This article provides an in‑depth tutorial on Apollo, Ctrip's open‑source distributed configuration center, covering its core concepts, architecture, four‑dimensional configuration model, client design, deployment, and step‑by‑step instructions for creating projects, adding configurations, testing dynamic updates, and running the service in Kubernetes with Docker.
ApolloConfiguration CenterDocker
0 likes · 22 min read

This article explains Nacos' advantages over Eureka, compares its Raft‑based consistency, details the Spring Cloud Alibaba suite, walks through Nacos architecture, installation, standalone and cluster modes, and provides practical examples of using Nacos as both a service registry and a configuration center in microservice projects.
ClusterConfiguration CenterNacos
0 likes · 34 min read

This article provides an in‑depth tutorial on Apollo, Ctrip's open‑source distributed configuration center, covering its concepts, architecture, four management dimensions, client design, deployment in Kubernetes, and step‑by‑step Spring Boot integration with code examples and configuration details.
ApolloConfiguration CenterDistributed Config
0 likes · 28 min read

This article explains the inner workings of Nacos' long‑polling mechanism, covering both client‑side scheduling and server‑side handling, with detailed code walkthroughs, architectural diagrams, and insights into how configuration changes are detected and propagated in a distributed system.
Configuration CenterJavaLong Polling
0 likes · 17 min read

This article explores Apollo’s distributed configuration center, focusing on its core architecture and the implementation of HTTP Long Polling, including code examples, timeout considerations, and strategies to ensure reliable message delivery across multiple client nodes.
ApolloConfiguration CenterLong Polling
0 likes · 12 min read

This article introduces DynamicTp, a Java framework that extends ThreadPoolExecutor with dynamic configuration, real‑time monitoring, and alerting, enabling developers to adjust thread‑pool parameters on the fly, integrate with popular configuration centers, and achieve high‑availability and scalability in microservice environments.
Configuration CenterDynamicTpJava
0 likes · 12 min read

This article explains the microservice architecture style, its evolution from monoliths, the technical challenges it introduces, compares leading open‑source solutions such as Dubbo, Spring Cloud Netflix, and Spring Cloud Alibaba, and details essential components like service registries, configuration centers, API gateways, tracing, fault tolerance, and monitoring.
API GatewayConfiguration CenterDubbo
0 likes · 48 min read

This guide walks through installing and using Spring Cloud Tencent with Polaris, covering environment setup, Polaris deployment, Spring Boot project configuration, service registration, configuration center integration, rate‑limiting, circuit‑breaker features, and metadata transfer, while highlighting common pitfalls and practical code examples.
Circuit BreakerConfiguration CenterMetadata Transfer
0 likes · 20 min read

This article explains how to build a lightweight, single‑machine configuration center for Spring Boot micro‑services, detailing the core classes, file scanning, variable pooling, environment initialization, YAML conversion, controller endpoints, and runtime property updates, while also discussing current limitations and future improvements.
Configuration CenterDynamic ConfigurationJava
0 likes · 13 min read

This article explains the evolution from monolithic to microservice architectures, compares their advantages and disadvantages, and details essential components such as service gateways, service registration and discovery mechanisms, and distributed configuration centers, while also reviewing popular open‑source solutions.
Configuration CenterService Registrationbackend architecture
0 likes · 28 min read

This article explains why a configuration center is essential for microservices, introduces Nacos as a centralized solution, and provides step‑by‑step instructions with code examples for integrating Nacos into Spring Boot, managing Data IDs, namespaces, groups, and dynamic configuration refresh.
Configuration CenterNacosSpring Boot
0 likes · 14 min read

This article explains the differences between monolithic and microservice architectures, outlines their advantages and disadvantages, and then dives into essential components such as service gateways, service registration and discovery, and distributed configuration centers, providing practical guidance for building scalable backend systems.
Configuration CenterService Registrationbackend architecture
0 likes · 26 min read

This article explains how Nacos configuration center works, clarifies that it uses a client‑initiated pull (long‑polling) model rather than push, and walks through key client and server source code components—including cacheMap, listeners, long‑polling handling, and configuration change notification – to help developers and interviewees master its internals.
Configuration CenterJavaLong Polling
0 likes · 17 min read

This article compares Nacos and Apollo configuration centers, examining their security models, environment isolation mechanisms, and architectural complexity, and concludes that Nacos offers a simpler and potentially safer solution for microservice deployments.
Configuration CenterNacosSecurity
0 likes · 9 min read

This article explores Tencent’s evolution from monolithic LAMP/MVC stacks to a container‑based microservice architecture, detailing the open‑source Polaris Mesh service mesh, Spring Cloud Tencent framework, and their gateway, naming, and configuration components, while highlighting deployment benefits and practical usage examples.
Configuration CenterPolaris MeshSpring Cloud Tencent
0 likes · 15 min read

This article compares Alibaba's Nacos and Ctrip's Apollo config centers, examining their security models, architectural complexity, and practical deployment differences to determine which solution offers better safety and simplicity for various system sizes.
ApolloConfiguration CenterNacos
0 likes · 6 min read

The article investigates why a Spring Boot application using Nacos as a configuration center does not inject bean properties defined locally when the Nacos console lacks those entries, by walking through the integration steps and analyzing the relevant source code.
Configuration CenterDebuggingNacos
0 likes · 11 min read

This article explains how Hippo4j 1.1.0 introduces a configuration‑center‑driven lightweight dynamic thread pool for Spring Boot applications, covering core features, alarm strategies, web‑container updates, code examples, and migration tips.
Configuration CenterHippo4JJava
0 likes · 13 min read

This article provides an in-depth comparison of Nacos with other configuration and registration centers, explains its architecture and design principles, and offers detailed step-by-step instructions for deploying Nacos in standalone and cluster modes, integrating it with Spring Boot for both configuration and service discovery, including code snippets and operational tips.
Configuration CenterDockerNacos
0 likes · 35 min read

This article provides a step‑by‑step tutorial on integrating Nacos as a service discovery registry and dynamic configuration center for Spring Cloud microservices, covering dependency setup, server installation, service registration, configuration management, namespaces, groups, and multi‑config sets with live refresh capabilities.
Configuration CenterNacosSpring Cloud
0 likes · 13 min read

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.
Configuration CenterService Discoverybackend development
0 likes · 26 min read

The ABF Platform Configuration Center serves as a factory‑style, configuration‑driven middle‑office development system that unifies application, page, permission, layout, and custom extensions, allowing nearly 100 % reuse of rendering functions and rapid, standardized creation of internal business applications.
ABF platformConfiguration CenterFrontend Architecture
0 likes · 9 min read

This article explains Nacos configuration center’s pull‑based data exchange, detailing the push vs pull models, long‑polling mechanism, core concepts like dataId, group, namespace, and provides in‑depth Java source‑code analysis of both client and server implementations.
Configuration CenterJavaLong Polling
0 likes · 16 min read

This article explains the definition of microservices, outlines the core challenges and standard components required for a microservice architecture, and discusses why Spring Cloud and Spring Cloud Alibaba are popular choices for building and managing such systems.
Configuration Centerbackend architecturemicroservices
0 likes · 10 min read

This article explains the purpose, requirements, architecture, setup steps, configuration model, client workflow, request protocol, data storage, gray release, and rollback mechanisms of Nacos's configuration center, providing a comprehensive guide for backend developers.
Config ManagementConfiguration CenterNacos
0 likes · 9 min read

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.
API GatewayConfiguration CenterService Discovery
0 likes · 19 min read

This article examines the architecture and features of Spring Cloud Config and Ctrip Apollo configuration centers, compares their strengths and weaknesses, and provides practical guidance for migrating from Spring Cloud Config to Apollo in microservice environments.
ApolloConfiguration CenterDistributed Configuration
0 likes · 12 min read

BRCC (Better Remote Config Center) is an open‑source, lightweight, Spring‑Boot‑based distributed configuration center that simplifies management of dynamic, multi‑environment settings across dozens of instances by offering easy SDK/API access, push notifications, traceability, fine‑grained security, high performance, and a user‑friendly UI.
BRCCBaidu open sourceConfiguration Center
0 likes · 12 min read

This article reviews microservice architecture, outlining selection principles, comparing popular frameworks such as Dubbo and Spring Cloud for service governance, evaluating API gateway options like Zuul, Traefik, and Kong, and discussing configuration center solutions including Spring Cloud Config, Apollo, and Nacos.
API GatewayConfiguration CenterService Governance
0 likes · 24 min read

This article explains the principles of long polling used by configuration centers like Nacos and Apollo, compares it with traditional polling and push models, and provides a complete Java demo showing client and server implementations for dynamic configuration updates.
ApolloConfiguration CenterJava
0 likes · 17 min read

This article explains how to design a configuration center, covering storage selection, environment isolation, push‑pull update mechanisms, Spring integration, permission auditing, metrics monitoring, and open APIs or multi‑language SDKs for practical implementation.
Configuration CenterSpring Integrationbackend architecture
0 likes · 9 min read

The article describes a mobile configuration center that lets native apps dynamically modify display logic and roll out features via gray‑release, supporting version‑specific delivery, rollback, and environment isolation, and details its evolution from a simple V1 design to an extensible V2 architecture with per‑KV control and caching.
Configuration CenterGray ReleaseSDK
0 likes · 13 min read

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.
Configuration CenterJavaNacos
0 likes · 11 min read

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.
Configuration CenterService Discoveryconsul
0 likes · 8 min read

This article explains how a high‑traffic advertising team designed and implemented a centralized configuration center using Consul, Consul‑Template, SaltStack, and Docker Registrator, covering its architecture, service registration, publishing, access control, and monitoring in detail.
Configuration CenterDockerKunkka
0 likes · 9 min read

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.
Configuration CenterService Discoverybackend development
0 likes · 4 min read

This article examines the limitations of Spring Cloud Config—especially Git‑based permission control and coarse granularity—explains why a database‑backed configuration center is preferable, and details a custom long‑polling refresh mechanism built with Spring's DeferredResult and asynchronous servlets.
Configuration CenterLong PollingSpring Boot
0 likes · 10 min read

This article explains why the default single‑node Nacos setup is unsuitable for production, walks through configuring MySQL as a centralized data store, provides step‑by‑step configuration examples, and discusses the trade‑offs of using centralized storage versus distributed algorithms.
Configuration CenterMySQLSpring Cloud
0 likes · 6 min read

This article explains how Spring Cloud Alibaba's Nacos module loads configuration by default, maps DataID, Group, and file extensions to client properties, and demonstrates three practical examples for customizing DataID, using YAML, and grouping configurations for different environments.
Configuration CenterSpring Cloudmicroservices
0 likes · 6 min read

This tutorial walks through the design and implementation of a distributed configuration center using Spring Boot, demonstrating how to define configuration entities, apply the observer pattern for dynamic updates, and integrate a thread‑pooled scheduler to keep configuration in sync without restarting services.
Configuration CenterJavaObserver Pattern
0 likes · 19 min read

This article explains how to implement various flow‑control strategies—static rate limiting, dynamic resource‑based limits, connection and concurrency controls—and demonstrates a practical, configuration‑center‑driven approach to globally throttle asynchronous MQ consumers using Alibaba Cloud ACM and Java.
Alibaba CloudConfiguration CenterFlow Control
0 likes · 8 min read

This article presents a multiplexed system testing environment that uses token‑based encoding and decoding to share a single baseline environment among multiple testing scenarios, detailing its architecture, technical components, protocol adaptation, token handling, and Zookeeper‑based configuration management to improve resource efficiency and testing speed.
Configuration CenterZooKeeperenvironment multiplexing
0 likes · 11 min read

The article introduces the need for a distributed configuration platform, outlines its typical scenarios and essential characteristics, and details the lightweight open‑source implementation Diablo—including its architecture, data model, Redis storage, client behavior, real‑time update mechanisms, and deployment recommendations.
BackendConfiguration CenterDistributed Configuration
0 likes · 10 min read
