Tagged articles
Apollo
68 articles · Page 1 of 1
Palantir partners with Armada to integrate its Sovereign AI Operating System — AIP, Ontology, Foundry, and Apollo — into modular Galleon data centers, enabling organizations to run open-weight models on controlled infrastructure with air-gapped deployment options, extending control from business logic to physical hardware.
Air-gapped DeploymentApolloArmada
0 likes · 21 min read

DynamicTp is a lightweight Spring Boot framework that enables runtime dynamic adjustment of thread pool parameters via configuration centers like Nacos and Apollo, provides real-time monitoring through MicroMeter and JSON logs, and integrates alerting for queue capacity, thread activity, rejection rates, and task timeouts across both application and third-party component thread pools.
ApolloDynamic ConfigurationDynamicTp
0 likes · 12 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

The article explains how large‑scale, million‑QPS systems transition from hard‑coded file configurations to centralized, dynamically pushed config centers, detailing the problems of file‑based configs, the benefits of externalization, dynamic updates, governance features, and the trade‑offs involved.
ApolloConfiguration ManagementDynamic Configuration
0 likes · 20 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

The Apollo 11 guidance computer faced near‑overload and alarmed during the final descent, yet Margaret Hamilton’s team used priority scheduling and fault‑tolerant design on a 32‑kg, 2 MHz machine with only a few kilobytes of memory, enabling the historic Moon landing.
Apolloembedded systemsfault tolerance
0 likes · 7 min read

This article details a production-grade system for implementing dynamic feature toggles and canary releases in Spring Boot, covering architecture design, config-center integration with Nacos/Apollo, code patterns using AOP and strategy routing, traffic-splitting algorithms with user stickiness, A/B test metrics collection, and toggle lifecycle governance with hard TTL cleanup.
ApolloNacosSpEL
0 likes · 20 min read

The article analyzes the pain points of configuration updates and gray releases, compares Nacos and Apollo across deployment effort, latency, rollback, format support and fine‑grained rollout, presents real‑world performance numbers, and provides a checklist to help teams pick the right solution for their specific needs.
ApolloConfiguration ManagementGray Release
0 likes · 8 min read

This article walks through the reasons for abandoning Nacos in favor of Apollo and provides a step‑by‑step tutorial that covers Apollo’s core concepts, architecture, client integration with Spring Boot, dynamic updates, environment/cluster/namespace handling, and deployment on Kubernetes.
ApolloConfiguration ManagementDocker
0 likes · 26 min read

This article compares Nacos and Apollo, the two most popular configuration centers in the microservice ecosystem, covering their design philosophies, quick‑start procedures, core features, data models, architecture, performance, operational costs, community support, and provides guidance on when to choose each solution.
ApolloConfiguration ManagementNacos
0 likes · 21 min read

This comprehensive guide walks you through the fundamentals, architecture, and key features of Ctrip's Apollo configuration center, then shows step‑by‑step how to create a Spring Boot client, manage environments, clusters, and namespaces, and finally package and deploy the application on Kubernetes with live configuration updates.
ApolloConfiguration ManagementKubernetes
0 likes · 27 min read

This guide walks through the fundamentals of Apollo Config Center, explains its core concepts, architecture, and dimensions, and demonstrates how to create a Spring Boot client, configure it for dynamic updates, test environment changes, and deploy the application on Kubernetes.
ApolloConfiguration ManagementKubernetes
0 likes · 22 min read

This article walks through the concepts, architecture, and hands‑on steps for using Apollo, Ctrip’s open‑source distributed configuration center, covering project setup, Spring Boot integration, dynamic updates, clustering, namespaces, high‑availability design, and Kubernetes deployment.
ApolloConfiguration ManagementJava
0 likes · 25 min read

This article explains what microservice configuration is, why centralized management is essential, and compares three popular configuration centers—Spring Cloud Config, Nacos, and Apollo—detailing their advantages, disadvantages, and suitable scenarios for cloud‑native architectures.
ApolloNacosSpring Cloud Config
0 likes · 7 min read

This step‑by‑step guide explains how to set up Ctrip's open‑source Apollo configuration center, create projects and namespaces, integrate it with a SpringBoot application, and deploy the app on Kubernetes while demonstrating dynamic updates, rollbacks, clustering, and environment switching.
ApolloConfiguration ManagementKubernetes
0 likes · 27 min read

This comprehensive guide walks you through Apollo's background, core model, four‑dimensional configuration management, client design, local caching, and deployment steps—including Maven setup, SpringBoot client implementation, Kubernetes Dockerization, and practical tests across environments, clusters, and namespaces.
ApolloConfiguration ManagementDevOps
0 likes · 26 min read

This article provides a detailed tutorial on Apollo, Ctrip’s open‑source distributed configuration center, covering its core concepts, features, model, four‑dimensional management, client design, deployment architecture, high‑availability considerations, step‑by‑step project creation, Spring Boot integration, Kubernetes deployment, and practical testing procedures.
ApolloConfiguration ManagementKubernetes
0 likes · 26 min read

A Spring Boot application on CentOS 6.x hung while fetching Apollo configuration because a single /etc/hosts entry listed dozens of domain names, causing hostname resolution to fail; splitting the entry into multiple lines restored normal startup and highlighted a kernel‑specific hosts parsing bug.
ApolloCentOSLinux
0 likes · 7 min read

This article provides a comprehensive tutorial on Apollo, covering its basic concepts, architecture, four-dimensional configuration model, client design, high‑availability considerations, and step‑by‑step instructions for creating a Spring Boot project, integrating Apollo dependencies, configuring environments, testing dynamic updates, and deploying the application on Kubernetes.
ApolloConfiguration ManagementJava
0 likes · 22 min read

This article provides a step‑by‑step tutorial on Apollo, an open‑source configuration center, covering its core concepts, dimensions, client design, Maven integration, Spring Boot setup, JVM parameters, testing scenarios, cluster/namespace usage, Docker image creation, and Kubernetes deployment for microservice applications.
ApolloConfiguration ManagementKubernetes
0 likes · 30 min read

This article provides an in‑depth tutorial on Apollo, Ctrip’s open‑source distributed configuration center, covering its concepts, features, four‑dimensional model, client architecture, deployment steps, SpringBoot integration, Kubernetes deployment, and practical testing scenarios for real‑time configuration updates.
ApolloConfiguration ManagementJava
0 likes · 22 min read

This article provides a step‑by‑step tutorial on Apollo, Ctrip’s open‑source distributed configuration center, covering its core concepts, features, architecture, four‑dimensional model, project creation, Maven dependencies, Spring Boot configuration, test controllers, various runtime scenarios, cluster and namespace usage, and deployment on Kubernetes with Docker.
ApolloConfiguration ManagementJava
0 likes · 23 min read

This article provides an in‑depth tutorial on Apollo, Ctrip's open‑source distributed configuration center, covering its concepts, features, architecture, four management dimensions, client design, Maven integration, SpringBoot implementation, testing procedures, and deployment on Kubernetes with Docker.
ApolloConfiguration ManagementJava
0 likes · 23 min read

This article provides a step‑by‑step tutorial on Apollo’s concepts, features, model, namespace handling, client design, high‑availability considerations, project creation, configuration management, Spring Boot client implementation, testing across environments, clusters and namespaces, and deployment on Kubernetes with Docker.
ApolloConfiguration ManagementKubernetes
0 likes · 25 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 provides a step‑by‑step tutorial on Apollo's configuration center, covering its core concepts, four‑dimensional model, client design, Spring Boot integration, testing of dynamic updates, and deployment via Docker and Kubernetes for cloud‑native applications.
ApolloConfiguration ManagementDocker
0 likes · 25 min read

A single overly long line in /etc/hosts caused Spring Boot to hang while fetching Apollo configuration on CentOS 6, and splitting the line into shorter entries resolved the issue, highlighting a subtle hosts‑file limitation in older Linux kernels.
ApolloCentOSLinux
0 likes · 6 min read

This article provides a step‑by‑step tutorial on integrating the Apollo configuration center into SpringBoot applications, covering basic concepts, client design, environment, cluster and namespace management, Maven setup, Docker image creation, and deployment on Kubernetes for dynamic configuration updates.
ApolloConfigurationDocker
0 likes · 21 min read


21CTOFeb 11, 2024 · Backend Development
This article explains how integrating Apollo with a microservice architecture enables developers to create highly scalable, resilient applications by detailing microservice fundamentals, challenges, best‑practice solutions, and practical steps for building extensible data graphs and robust monitoring.
ApolloGraphQLmicroservices
0 likes · 10 min read

This article provides a step‑by‑step tutorial on deploying the Ctrip Apollo configuration center, creating projects and namespaces, integrating Apollo with a Spring Boot application, configuring environments, clusters and namespaces, and testing dynamic configuration updates in Kubernetes, covering all essential concepts and practical code examples.
ApolloConfiguration ManagementSpring Boot
0 likes · 27 min read

This article provides a comprehensive guide to Ctrip’s open‑source Apollo configuration center, covering its core concepts, features, architecture, deployment dimensions, client design, code examples for a SpringBoot project, testing procedures, and Kubernetes deployment with Docker.
ApolloConfiguration ManagementDocker
0 likes · 28 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 walks through installing Ctrip's open‑source Apollo configuration center using Docker‑Compose, explains its key features, shows how to deploy it on Kubernetes with Helm, and provides .NET SDK integration examples and practical tips.
.NETApolloConfiguration Management
0 likes · 10 min read

Baidu unveiled Apollo Open Platform 9.0 on December 19, delivering Package Management 2.0, new perception models with 4D millimeter‑wave radar support, incremental training, and a revamped Dreamview+ UI, and will host two live‑stream courses on December 27‑28 to explain the PnC and perception upgrades, with gifts for registrants.
AIApolloAutonomous Driving
0 likes · 3 min read

The article examines how Apollo’s long‑polling and push‑pull design cause massive database bandwidth spikes during large namespace updates in promotion periods, analyzes the RemoteConfigLongPollService and repository code, and proposes three optimizations—key‑level synchronization, MD5‑based change detection, and circuit‑breaker handling—while weighing real‑time versus periodic update trade‑offs.
ApolloConfiguration ManagementPerformance Tuning
0 likes · 10 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 explains Apollo’s distributed configuration center, its overall architecture, the use of HTTP long polling with Spring’s DeferredResult, code examples for listening and publishing config changes, and strategies to ensure message reliability across multiple nodes.
ApolloDistributed ConfigurationJava backend
0 likes · 11 min read

The article explains Apollo’s client‑side long‑polling workflow, how the Config Service suspends requests with Spring DeferredResult, stores them in a cache, and notifies clients of configuration changes via database messages and background scanning, enabling immediate config refresh.
ApolloConfiguration ManagementLong Polling
0 likes · 3 min read


转转QAAug 31, 2023 · Backend Development
The article recounts a production incident where a new backend feature introduced a NullPointerException due to directly mutating an Apollo configuration object, describes the debugging steps taken—including log analysis, environment replication, service restart, and code review—and explains the final fix of returning a copy of the configuration to prevent shared‑state corruption.
ApolloJavaNullPointerException
0 likes · 8 min read

This article explains why Apollo configuration stops working after switching from @Value to @FeignClient in a Spring Boot project, analyzes the loading order of Spring's configuration mechanisms, and shows how to adjust the bootstrap settings to resolve the issue.
ApolloConfigurationFeignClient
0 likes · 9 min read

MINOS, a low‑code configuration platform for NetEase Yanxuan, translates Apollo’s technical data model into business‑friendly visual forms, lets developers and product users create and approve configurations online, cuts manual R&D effort from minutes to seconds, and has already produced over 4,000 forms across multiple lines.
ApolloR&D managementWorkflow
0 likes · 10 min read

The article presents a comprehensive solution for improving interface reuse, domain‑model abstraction, and front‑back collaboration by building a GraphQL‑based Model Management Platform (GMP) that supports data‑model management, service orchestration, request generation, caching, authentication, and monitoring, complete with tooling and workflow integration.
API ReuseApolloCache
0 likes · 18 min read

This comprehensive guide explains why a service gateway is needed in microservice architectures, details Spring Cloud Gateway's core concepts, deployment steps, route and predicate configurations, local and global filters, integration with Nacos for service discovery, dynamic routing via Apollo, and custom global exception handling, providing code examples throughout.
ApolloJavaNacos
0 likes · 24 min read

This article explains the underlying principles of Sentinel's cluster rate‑limiting feature, compares embedded and independent deployment modes, and provides a step‑by‑step Java/SpringBoot implementation with Apollo dynamic configuration and sample test code.
ApolloClusterJava
0 likes · 17 min read

This article shares Ctrip's experience building GraphQL‑based Backend‑for‑Frontend services, covering the technology stack, data‑graph modeling, error handling with union types, non‑null field usage, performance optimizations, engineering practices such as data‑loader batching, virtual paths, monitoring, and testing.
ApolloBFFGraphQL
0 likes · 21 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

This article explains the fundamentals of configuration centers, compares four popular solutions—Apollo, Disconf, Spring Cloud Config, and Nacos—covering their features, real‑time updates, gray releases, permission management, multi‑environment support, and performance to help you make an informed selection.
ApolloConfiguration ManagementNacos
0 likes · 21 min read

This article introduces a modular, server‑driven dynamic layout system built on the Apollo configuration platform that enables rich UI components, instant preview, version‑controlled deployment, and cross‑platform support to address diverse layout requirements without additional code releases.
ApolloUI customizationcross‑platform
0 likes · 9 min read

This article compares three popular open‑source configuration centers—Spring Cloud Config, Apollo, and Nacos—across product features, user experience, deployment, multi‑language support, migration, performance, and high‑availability to help engineers choose the most suitable solution for microservice environments.
ApolloNacosSpring Cloud Config
0 likes · 16 min read

This tutorial provides detailed commands and configurations for installing a specific Docker version, setting up persistent MySQL containers, importing Apollo database scripts, and deploying Apollo Config, Admin, and Portal services using Docker on a CentOS host.
ApolloDockerOperations
0 likes · 5 min read

This article introduces the need for dynamic configuration in Spring Boot microservices, compares popular open‑source configuration centers such as Apollo, Nacos, Spring Cloud Config, Disconf, and Diamond, and provides detailed features, a comparison table, and code examples for integrating Apollo.
ApolloDistributed ConfigurationJava
0 likes · 11 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

This article explains why using GraphQL instead of REST offers significant architectural benefits, covering hexagonal architecture, infrastructure components, the data graph concept, self‑documenting schemas, federation, and how it empowers frontend developers while simplifying versioning and development.
ApolloBackendData Graph
0 likes · 14 min read

The article reviews five widely used GraphQL tools—Prisma, Relay, Apollo, Hasura, and URQL—explaining their core features, supported databases or frameworks, and providing direct links to their official websites for developers seeking to simplify GraphQL integration.
ApolloBackendGraphQL
0 likes · 6 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 analyzes the performance bottleneck caused by large Apollo configuration reads in a PHP application and presents multiple optimization strategies—including static variables, Yac/APCu caching, require‑file with opcache, and MessagePack serialization—to significantly lower CPU and memory consumption while maintaining configuration freshness.
ApolloCachingMessagePack
0 likes · 11 min read

Facing massive, multi‑system log volumes, China Minsheng Bank’s big‑data team designed a real‑time intelligent log platform by integrating Ctrip’s open‑source Apollo configuration center with Elasticsearch, enabling centralized, versioned, hot‑reloading configuration, role‑based parameter management, and high‑availability deployment across thousands of servers.
ApolloDevOpsElasticsearch
0 likes · 30 min read

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.
ApolloEurekaService Discovery
0 likes · 15 min read

This article explains how the IoT business platform adopts Alibaba Sentinel to provide circuit breaking and rate‑limiting for Dubbo microservices, integrates with Apollo for centralized rule distribution, implements automatic downgrade, thread isolation, and cache‑based degradation to improve system reliability and resilience.
ApolloDubboSentinel
0 likes · 9 min read

This tutorial explains the limitation of Sentinel Dashboard rule persistence, analyzes the data flow, and provides a step‑by‑step solution using DynamicRuleProvider and DynamicRulePublisher to read and write flow rules in Apollo, complete with code examples and configuration details.
ApolloSentinelflow-control
0 likes · 11 min read

This article explains the origins and problems GraphQL solves, describes its core concepts and advantages, and provides step‑by‑step instructions for integrating GraphQL into a Vue front‑end with Apollo as well as setting up a simple Node.js GraphQL server, complete with code examples.
APIApolloGraphQL
0 likes · 10 min read

Centralized configuration becomes essential as applications grow in complexity, prompting a detailed comparison of open‑source config centers—Spring Cloud Config, Ctrip Apollo, and Disconf—highlighting features, compatibility, usability, and ultimately recommending Apollo as the optimal solution for SpringBoot‑based microservices.
ApolloConfiguration ManagementDisconf
0 likes · 7 min read

This article explains why a configuration center is essential for modern micro‑service architectures, describes the typical architecture and governance capabilities of Apollo, details its high‑availability and real‑time mechanisms, and showcases practical use cases such as feature switches, service governance, dynamic logging, routing, and data‑source management.
ApolloConfiguration ManagementDynamic Configuration
0 likes · 18 min read

GraphQL, created by Facebook in 2012 and open‑sourced in 2015, offers a flexible, efficient alternative to REST by allowing clients to request exactly the data they need, reducing redundancy, cutting request counts, and simplifying API evolution, with practical Node server and Apollo client implementations illustrated.
API DesignApolloGraphQL
0 likes · 5 min read

This article presents a practical, China‑focused microservice reference stack built on Spring Cloud, detailing core support components such as Zuul, Eureka, Apollo, and Spring Boot, as well as monitoring tools like Kafka, ELK, CAT, KairosDB, ZMon, and Hystrix, and explains when and how to apply each in production environments.
ApolloKafkabackend architecture
0 likes · 20 min read


21CTOOct 9, 2017 · Databases
Since its inception, Facebook has relied on MySQL to handle data from over two billion users, but recent shifts toward NoSQL have led to the development of Apollo—a layered storage system inspired by Paxos, Raft, RocksDB, and custom APIs, aiming to improve scalability, latency, and fault tolerance.
ApolloFacebookMySQL
0 likes · 8 min read

This article analyzes a production incident where a Java web application using Apollo configuration center encountered "Too many open files" errors, detailing the fault symptoms, root cause analysis involving Tomcat's classloader and file‑descriptor limits, and presenting remediation and preventive measures.
ApolloClassLoaderJava
0 likes · 13 min read
