This article walks you through Redis’s architectural journey—from a simple single‑node setup, through persistence mechanisms, master‑slave replication, Sentinel‑driven automatic failover, and finally sharding with Redis Cluster—explaining each component’s purpose, trade‑offs, and how they collectively boost performance and reliability.
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.
This comprehensive tutorial walks you through MongoDB replica set concepts, member roles, primary election, configuration commands, as well as sharding fundamentals, shard key selection, cluster deployment, balancer management, and practical code examples for building a production‑grade database cluster.
This article explains Redis Cluster's sharding architecture, demonstrates how to configure multiple Redis nodes on different ports, shows commands for creating and testing the cluster, and illustrates failover behavior, highlighting its scalability and high‑availability advantages over Sentinel mode for large‑scale data workloads.
This article provides an in‑depth overview of Redis, covering its core concepts, data structures, performance characteristics, persistence mechanisms, high‑availability solutions, clustering, cache design patterns, operational best practices, and underlying implementation details for developers and architects.
This article provides a comprehensive overview of Redis, covering its core concepts, deployment architectures—including single instance, high‑availability, Sentinel, and cluster setups—its replication mechanisms, gossip protocol, and the various persistence options such as RDB, AOF, and fork‑based snapshots.
This article explains Elasticsearch fundamentals—including clusters, nodes, shards, replicas, segments, routing, indexing, updates, deletions, search flow, pagination methods, and visualization tools—while offering practical optimization recommendations for high‑performance and scalable deployments.
This article introduces Redis as an in‑memory key‑value data‑structure server, explains its primary use cases, walks through deployment options such as single instances, high‑availability, Sentinel and Cluster, and details its persistence mechanisms including RDB, AOF and forking.
This guide explains Redis's three clustering modes—master‑slave, Sentinel, and Cluster—detailing their architectures, failover mechanisms, PSYNC replication, configuration files, Spring Boot integration, and step‑by‑step testing to achieve high availability and scalability.
This guide compiles 100 practical kubectl commands that help you diagnose cluster information, pods, services, deployments, networking, storage, security, autoscaling, and many other Kubernetes components, providing a handy reference for effective cluster troubleshooting.
This guide explains how to use Kind—a Docker‑based tool for creating Kubernetes test clusters—including its architecture, network model, installation steps, cluster creation commands, multi‑node and multi‑control‑plane configurations, image loading, custom port mappings, ingress deployment, troubleshooting tips, and best‑practice recommendations.
This article provides a concise, practical guide to Kubernetes fundamentals, covering pod creation, the essential compute‑network‑storage resources, cluster components, native objects like Deployments and StatefulSets, and the trade‑offs of standardization, elasticity, and extensibility.
The article explains how Redis Cluster distributes keys using CRC16‑based hash slots instead of traditional consistent hashing, detailing the slot calculation, node addition and removal processes, client redirection, smart client optimizations, and the design reasons behind the fixed 16,384 slot count.
This article explains the fundamentals of scheduled tasks, highlights the limitations of single‑node solutions, introduces the open‑source XXL‑JOB platform, walks through its architecture, installation, configuration, task creation, routing strategies, clustering, sharding and GLUE mode, and offers practical code examples for Java/Spring‑Boot projects.
A detailed investigation of an Elasticsearch timeout incident reveals how an overly aggressive node_concurrent_recoveries setting caused CPU saturation, disk I/O spikes, and shard relocation overload, and outlines the steps taken to isolate the faulty node and restore cluster performance.
The team traced read‑request timeouts to a single overloaded Elasticsearch node where an excessively high node_concurrent_recoveries setting caused many simultaneous shard recoveries and disk‑watermark‑driven relocations, and resolved the issue by lowering concurrent recoveries, enabling adaptive replica selection, and adjusting allocation settings.
This article explains Redis Cluster’s decentralized architecture, slot‑based sharding, node communication, data migration, and client redirection mechanisms, showing how to scale Redis horizontally while maintaining high availability and fault‑tolerance for large‑scale applications.
This guide walks through a systematic approach to diagnosing Kubernetes problems, covering pod startup failures, cluster health checks, event logs, pod status, network and storage verification, container logs, DNS service checks, and provides practical commands and tips for each step.
This guide explains how to claim Alibaba Cloud's free ECS credits, use them to spin up multiple machines for hands‑on Redis cluster experiments, and outlines a step‑by‑step learning path from basic Nginx setups to advanced high‑availability and multi‑service architectures.
This article describes a real‑world OceanBase failure scenario where a core dump fills the data disk, and provides a step‑by‑step guide to shrink datafiles to 80% of disk capacity, adjust parameters, reduce tenant replicas, offline and reinstall OBServer instances, and finally restart the cluster.
This guide demonstrates how to integrate RocketMQ 4.8.0 into a Spring Boot 2.4.12 application, covering dependency setup, configuration, sending and receiving normal, ordered, cluster/broadcast, and transactional messages, complete with code snippets and execution results to help developers implement reliable messaging patterns.
This article introduces Redis as an open‑source in‑memory key‑value store, explains its data‑structure server nature, outlines common deployment options—including single instance, high‑availability, Sentinel, and Cluster—describes replication mechanisms, and details persistence models such as RDB, AOF, and hybrid approaches.
This comprehensive guide explains Redis fundamentals, its rich data types, differences from Memcached, thread model, persistence mechanisms (AOF, RDB, hybrid), memory eviction policies, clustering for high availability, cache design patterns, distributed locking, Redlock algorithm, and practical techniques for identifying and safely deleting big keys.
A service‑wide avalanche occurred when a Redis 3.x master‑slave failover coincided with Jedis’ default 2‑second connection timeout and six retry attempts, causing up to 60‑second latencies; adjusting connectionTimeout, soTimeout to 100 ms and reducing maxAttempts to two limited latency to about one second and prevented cascade failures.
This article explains how Redis Sentinel provides automated failover, details the replication process that keeps master and slave data synchronized, and compares the roles of master‑slave replication, Sentinel, and Redis Cluster in achieving high availability and horizontal scalability.
Redis is an open‑source, in‑memory key‑value store written in C that uses hash tables, various data structures, and a single‑threaded event loop to achieve high performance, and this article explains its basic types, persistence mechanisms (AOF and RDB), replication, sentinel failover, and cluster sharding.
This article provides a step‑by‑step guide to deploying a Nacos cluster on Linux, covering environment preparation, installation, MySQL configuration, application.properties settings, and cluster.conf setup, startup commands, and explains the Raft‑based leader election and data synchronization mechanisms for reliable microservice registration.
This tutorial walks through the complete process of preparing three CentOS 7 nodes, installing ceph‑deploy, configuring storage and network topology, and sequentially deploying monitors, managers, OSDs, MDS, RGW, enabling the Ceph dashboard, performing verification tests, and finally uninstalling the cluster.
This article explains how to use redis-benchmark for performance testing, compares single‑node and cluster throughput, and details Redis Cluster's hash‑slot architecture, including CRC16 hashing, slot allocation, scaling considerations, and operational nuances.
This guide walks you through MongoDB sharding fundamentals, step‑by‑step cluster setup, common failure diagnostics, and practical commands, enabling you to build, manage, and optimize a sharded MongoDB deployment for scalable storage and high‑performance applications.
Redis is an open‑source, in‑memory key‑value data‑structure server that serves as a fast cache and primary database, offering various deployment options—including single instances, high‑availability setups, Sentinel, and clustering—along with flexible persistence mechanisms such as RDB snapshots and AOF logging.
This comprehensive guide explains MongoDB cluster architecture, component roles, common use cases, monitoring commands, essential maintenance operations, data migration steps, troubleshooting of typical production issues, and practical optimization recommendations for high‑performance deployments.
This article provides a comprehensive overview of high‑performance computing, covering system architectures, hardware components, performance metrics, network topologies, common parallel file systems, cluster management functions, mainstream job‑scheduling systems, and MPI‑based parallel programming models.
This article introduces K3s, the CNCF‑certified lightweight Kubernetes distribution, explains its core features, walks through installing a local cluster, adding nodes, deploying an Nginx service with ingress, and compares K3s to full‑size K8s to help decide when to use it.
This article provides a comprehensive guide to Redis Cluster, covering its sharding mechanism, hash slot mapping, replication and automatic failover, client data location, slot reassignment, MOVED/ASK redirection, communication overhead, and practical tuning tips for large‑scale deployments.
This article provides a comprehensive overview of Redis, covering its role as an in‑memory data‑structure server, various deployment topologies such as single instances, high‑availability, Sentinel, replication, and clustering, as well as its persistence mechanisms including RDB, AOF, and fork‑based snapshots.
This guide walks developers through transforming a single‑node Redis cache into a stable, high‑performance cluster by explaining data persistence options (RDB, AOF, hybrid), master‑slave replication, Sentinel‑driven automatic failover, and both client‑side and proxy‑based sharding for horizontal scalability.
This article explains why the Lettuce asynchronous Redis client, built on Netty, outperforms the traditional Jedis client for high‑concurrency caching, covering Redis client differences, Netty NIO fundamentals, Redis Cluster architecture, smart client redirection handling, and practical Java code examples.
This comprehensive guide explains what Elasticsearch does, its underlying Lucene technology, core concepts such as clusters, shards, replicas, mapping, indexing and storage mechanisms, and provides practical performance‑tuning advice for building and operating a robust distributed search engine.
This comprehensive guide covers Redis fundamentals, pipeline, pub/sub, expiration strategies, transactions, persistence mechanisms, distributed lock implementations, and the three clustering modes, while also addressing common cache problems and practical deployment steps.
This article explains why modern internet products need caching to handle massive real‑time data, introduces Redis as an in‑memory database with persistence, master‑slave replication, and clustering, and demonstrates how these techniques dramatically improve performance, scalability, and reliability of web services.
This article provides a comprehensive overview of Redis, covering its definition as an in‑memory data structure server, various deployment topologies such as single instance, high‑availability, Sentinel, and Cluster, as well as detailed explanations of persistence mechanisms, forking, replication, and practical considerations for scaling and reliability.
This article analyzes the latency spikes observed in large‑scale Redis clusters after node expansion, identifies the CLUSTER SLOTS command and slot‑migration handling in hiredis‑vip and Jedis as the root cause, proposes a slot‑traversal optimization, and demonstrates a ten‑fold performance improvement with detailed benchmarks.
This tutorial explains why message queues are essential, compares popular MQ products, details RocketMQ's core components, and provides step‑by‑step instructions—including environment setup, broker configuration, firewall rules, and monitoring—to deploy a fault‑tolerant RocketMQ cluster on CentOS 7.
This article details Alibaba Cloud's Flink Cluster Inspector, explaining the business challenges of hotspot machines, the analysis of resource over‑use, and the four‑stage solution—pre‑profiling, in‑process self‑healing, post‑recovery, and observability—that reduces latency, cuts costs, and improves operational efficiency.
This article explains how Redis achieves high availability through master‑slave replication, automatic failover with Sentinel, and true sharding with Redis Cluster, while also comparing popular sharding solutions such as client‑side hashing, Twemproxy, and Codis.
This article explains the fundamental concepts of Redis cluster architecture, covering high‑availability with Sentinel, data partitioning methods, proxy‑based sharding techniques, the mechanics of Redis Cluster without a central node, and practical considerations for multi‑key operations in a distributed environment.
This guide explains RabbitMQ clustering concepts, compares classic and mirrored modes, provides step‑by‑step commands to set up a multi‑node RabbitMQ cluster, and shows how HAProxy and Keepalived can be combined to achieve true high‑availability and load balancing.
This guide explains Redis high‑availability mechanisms, covering master‑slave replication, the Sentinel monitoring and automatic failover process, and the Redis Cluster sharding architecture, including hash slots, MOVED/ASK redirection, gossip communication, and practical considerations such as data consistency, network partitions, and slot allocation.
This article explains why Redis clusters need distributed metadata, compares centralized and decentralized metadata storage, introduces the epidemic‑style Gossip protocol, and details how Redis Cluster implements Gossip messaging, node discovery, failure detection, and state synchronization through concrete code examples.
This article provides a comprehensive overview of Elasticsearch, covering data types, Lucene fundamentals, cluster architecture, shard allocation, indexing mechanisms, storage strategies, refresh and translog processes, segment merging, performance tuning, and JVM optimization for building scalable, near‑real‑time search solutions.
This guide explains ClickHouse’s core concepts, application scenarios, table engine families, detailed engine configurations, SQL development standards, cluster architecture, ZooKeeper’s role, chproxy usage, client tool options, availability considerations, and performance‑tuning parameters for high‑throughput OLAP workloads.
This article provides a comprehensive introduction to Elasticsearch, covering data types, Lucene fundamentals, cluster architecture, node roles, shard and replica mechanisms, mapping, basic usage, installation steps, health monitoring, indexing workflow, storage strategies, refresh and translog handling, segment merging, and practical performance tuning tips.
This article explains the key components of the Kubernetes master control plane, the mechanisms of Replication Controllers and ReplicaSets, and the role of kube-proxy in providing service IPs and load balancing across the cluster.
Redis is an open‑source, in‑memory key‑value store that functions as a data‑structure server, offering caching, replication, high‑availability, clustering, and various persistence options such as RDB snapshots and AOF logs, with detailed deployment models including single instances, Sentinel, and cluster architectures.
This article examines Redis 6.0 and 5.0 new features, compares various deployment architectures—including master‑replica, cluster, and read/write‑split—and provides practical guidance, code examples, and performance considerations to help engineers select the optimal Redis setup for production environments.
This article explains the features, advantages, drawbacks, and step‑by‑step installation process of a MySQL high‑availability Percona XtraDB Cluster (PXC), covering configuration, firewall settings, SELinux disabling, node initialization, clustering parameters, and verification commands.
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.
This article explains why single‑node Redis suffers from single‑point failures, describes the master‑slave replication model, details the Sentinel automatic failover mechanism, compares various sharding solutions like client‑side sharding, Twemproxy, Codis, and outlines the features and deployment considerations of Redis Cluster.
This article explains how Redis tackles single‑point failures with master‑slave replication, introduces Sentinel for automatic failover, compares client‑side and proxy sharding solutions like Twemproxy and Codis, and details the native Redis Cluster architecture for true distributed storage and high availability.
This comprehensive guide covers everything from Redis fundamentals, data structures, and thread model to persistence strategies, clustering, memory eviction policies, cache design patterns, and advanced use‑cases like delayed queues, large‑key handling, pipelines, transactions, and distributed locking, providing interview‑ready knowledge for developers.
Redis 7.0.3 has been released with medium‑urgency upgrades that improve performance and resource utilization, add new INFO fields and module APIs, enhance CLI clustering support, and fix a range of bugs including TLS handling, cluster failover, and command‑line configuration issues.
This tutorial explains step‑by‑step how to expand a Redis cluster from three masters and three slaves to four masters and four slaves by preparing a new configuration, starting the new instance, and using redis‑cli to add the node and verify slot distribution.
Redis is an open‑source, in‑memory data store that supports various data types, persistence, replication, Sentinel, clustering, Lua scripting, pipelines, and distributed locks, and the article walks through its evolution from simple caching to a high‑availability, horizontally scalable database solution.
Redis provides multiple high‑availability solutions—including master‑slave replication, Sentinel automatic failover, client‑side sharding, proxy‑based sharding (Twemproxy, Codis), and the native Redis Cluster—each with distinct architectures, advantages, and trade‑offs for scaling, fault tolerance, and operational complexity.
This article provides a detailed, English-language tutorial on preparing the network environment, creating necessary directories, configuring Redis instance files, launching six Redis nodes, and initializing a clustered Redis deployment across three servers using Linux command‑line tools.
This article explains the fundamentals of structured and unstructured data, introduces Lucene's inverted index, describes Elasticsearch's distributed cluster architecture, node roles, sharding and replication mechanisms, indexing workflow with refresh and translog, storage segment model, and provides practical performance‑tuning recommendations.
Redis is a single‑threaded, in‑memory data store offering rich structures, configurable expiration, multiple eviction policies, asynchronous master‑slave replication with Sentinel failover, durable RDB snapshots plus AOF logging, and native clustering that shards data across many masters for horizontal scalability and high availability.
This guide walks through installing a Redis cluster with three masters and three slaves using local ports, explains slot allocation, key hashing, gossip communication, failover, node addition, resharding, and best practices for high availability, while providing practical commands and configuration examples.
This article provides a comprehensive tutorial on why to use Elasticsearch, how to pull the Docker image, set up data directories, configure cluster and node settings, adjust system limits, launch three Elasticsearch containers, and verify the cluster using REST APIs and the elasticsearch‑head UI.
This article explains how a large-scale customer service instant messaging platform uses clustered WebSocket services, Redis, Nginx load balancing, and message‑queue broadcasting to achieve real‑time, reliable message delivery and robust reconnection handling across multiple servers.
This article compares Redis dual‑active designs—hot‑standby, various dual‑write models, and bidirectional synchronization—showing hot‑standby’s high cost, dual‑write’s latency or consistency trade‑offs, and arguing that a middleware‑driven bidirectional sync, using replication protocols and fixed‑prefix keys to avoid loops, offers the most practical solution.
This article provides a comprehensive technical guide on Redis performance, covering single‑threaded characteristics, master‑slave replication, Sentinel high‑availability mechanisms, Redis Cluster architecture, configuration steps, code examples, and alternative middleware solutions for scaling and fault tolerance.
This article provides a comprehensive overview of high‑performance computing (HPC), covering its definition, hardware architectures, performance metrics, cluster components, parallel file systems, management and scheduling tools, as well as common MPI implementations and links to further technical resources.
This guide explains why a TiKV node remains pending offline after a scale‑out and scale‑in operation, walks through detailed log inspection, region checks, and command‑line troubleshooting, and provides a step‑by‑step solution to forcefully remove the problematic region and clean up the store.
This article explains how Nacos registers services by detailing the client‑side request assembly, random node selection in a cluster, routing forwarding, and server‑side handling, while providing code snippets, diagrams, and practical tips for debugging the registration flow.
This article provides a comprehensive overview of ClickHouse, an open‑source column‑oriented MPP analytical database, covering its advantages and drawbacks, key features, typical use cases, data access flow, installation steps, core directories, indexes, data types, database and table engines, as well as detailed cluster architecture and deployment patterns.
Rb (Redis Blaster) is a Python library built on python‑redis that provides a custom routing system for non‑replicated sharding, allowing automatic key‑based routing, parallel execution, fan‑out and mapping across multiple Redis nodes without manual request distribution.
This article walks through the complete process of setting up a Ceph storage cluster on the domestically‑produced Kylin v10 operating system, covering hardware preparation, host configuration, manual installation of Ceph packages, monitor, OSD, and manager deployment with all necessary command‑line examples.
This comprehensive guide explains Elasticsearch fundamentals, including data types, Lucene and inverted indexes, cluster and node roles, shard and replica mechanisms, mapping, installation steps, health monitoring, write and storage processes, segment merging, and practical performance tuning tips for large‑scale search deployments.
This article provides a comprehensive overview of Redis, covering its definition, data structures, performance characteristics, persistence mechanisms, expiration strategies, memory eviction policies, hot key handling, cache pitfalls, deployment modes, Sentinel and Cluster features, and replication details, all framed as interview questions.
This guide explains the Percona XtraDB Cluster (PXC) architecture, its advantages and limitations, and provides step‑by‑step commands for removing MariaDB, opening firewall ports, disabling SELinux, downloading packages, configuring MySQL, bootstrapping the first node, adding additional nodes, and verifying the cluster status.
This article provides a comprehensive overview of Elasticsearch, covering its data types, Lucene-based inverted index, cluster architecture, sharding and replication mechanisms, mapping definitions, basic usage, health monitoring, storage internals, and practical performance tuning tips for large‑scale search deployments.
A Kubernetes pod appeared healthy but failed to receive heartbeats because its DNS search domain included a top‑level "HOST" entry, causing incorrect name resolution, and the article explains the root cause, analysis, and practical fixes such as using fully qualified names or adjusting ndots and dnsPolicy.
This article presents a simulated interview that explains Redis's evolution from single‑threaded to optional multithreading, its in‑memory performance advantages, persistence options (AOF, RDB, hybrid), high‑availability architectures, and the consistent‑hashing based slot allocation used by Redis Cluster.
This step‑by‑step tutorial shows how to build Undermoon from source, deploy a memory broker, coordinator, two server proxies and four Redis nodes on a single machine, register them via JSON APIs, create a named cluster, and verify its operation with redis‑cli.
This guide walks through setting up an Undermoon Redis cluster using Docker Compose, covering prerequisites, building images, registering proxies, creating and scaling the cluster, and demonstrating automatic failover with concrete command‑line examples.
The article explains how Undermoon’s Chunk, composed of two proxies and four Redis nodes spread across two machines, forms the core building block for a balanced Redis cluster topology and load‑balancing strategy, detailing its node layout, failover behavior, and simple allocation algorithm.
This article explains why Elasticsearch should run in a cluster, describes the cluster concept, provides step‑by‑step configuration for three nodes on macOS/Windows, demonstrates health checks, failover, horizontal scaling, routing calculations, shard control, and the read/write workflow, all illustrated with code snippets and screenshots.
This guide walks through deploying a Redis cluster on Kubernetes, covering the challenges of stateful workloads, the use of StatefulSets and Headless Services, configuration of persistence, and step‑by‑step commands to create, initialize, and expose the cluster.
This guide shows how to use the Bitnami Helm chart to quickly deploy a Redis Cluster in a Kubernetes "redis" namespace, customize its values.yaml, retrieve the auto‑generated password, and add RedisInsight with a persistent volume for web‑based management.
Learn how to deploy a Redis cluster on Kubernetes using a StatefulSet and Headless Service, covering problem analysis, key concepts, configuration steps, initialization with redis-cli, and creating services for access, all without persistent volumes for simplicity.
This article provides a thorough introduction to Redis, covering its core data structures and common commands, persistence options (RDB and AOF), memory‑management and eviction policies, pipelining, transactions and Lua scripting, performance optimization techniques, replication, Sentinel high‑availability, cluster sharding, and a comparison of popular Java clients.
This article explains why Redis achieves extremely high performance by being an in‑memory key‑value store, using compact data structures, a single‑threaded command model with epoll‑based I/O multiplexing, efficient hash tables, progressive rehashing, various persistence options, master‑slave replication, Sentinel monitoring and a sharded Cluster architecture.
In a large‑scale Redis cluster, expanding nodes caused unexpected CPU spikes and higher latency for MGET operations, prompting a deep investigation that traced the issue to the CLUSTER SLOTS command and its handling of MOVED errors, followed by a code‑level optimization that reduced CPU usage by over 90% and cut command latency dramatically.
This article explains how to expand a ClickHouse cluster by adding new replica nodes, detailing the use of the internal_replication parameter, configuration steps for ReplicatedMergeTree and MergeTree engines, and verification of data synchronization across replicas.
This article provides a thorough overview of Redis, covering its core data structures and common commands, persistence options, memory management and eviction policies, pipelining, transactions, Lua scripting, performance optimization techniques, replication with Sentinel, cluster sharding, and a comparison of popular Java clients.
The article examines Jedis 3.5.0’s three Redis access modes—single‑node via Jedis, sharding via ShardedJedis, and cluster via JedisCluster—detailing their class hierarchies, connection handling, consistent‑hashing and slot logic, and how pipelines boost throughput while respecting mode‑specific constraints.
This article introduces various Redis scaling solutions—including basic partitioning, master‑slave replication, Sentinel high‑availability, and Redis Cluster—explaining their concepts, typical usage patterns, configuration commands, advantages, and drawbacks to help developers choose the right approach for high‑traffic environments.
This article explains the main Redis scaling approaches—including simple partitioning, master‑slave replication, Sentinel high‑availability, and native Cluster—detailing their concepts, usage methods, advantages, drawbacks, and providing practical configuration commands and code examples.
