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.
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 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.
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.
This article investigates the high CPU usage and latency observed after expanding a large Redis cluster, analyzes the root cause in the CLUSTER SLOTS implementation and client MOVED handling, proposes an optimized slot‑traversal algorithm, and demonstrates significant performance improvements through benchmarking and profiling.
In large Redis clusters the original CLUSTER SLOTS implementation traversed every master and all 16,384 slots, causing ~52 % CPU usage and high MGET latency during migrations, but redesigning it to iterate the pre‑built slot array reduced complexity to O(total slots), cutting execution time from 2 ms to 0.17 ms and eliminating the CPU hotspot, a fix now merged into Redis 6.2.2.
This article explains the three Redis clustering modes, details how Redis Cluster uses 16384 hash slots calculated by CRC16, describes the rationale behind the slot count, and outlines the gossip‑based heartbeat communication and message format between master nodes.
Redis, an open‑source in‑memory data store, serves as a database, cache, and message broker, offering rich data types, persistence, replication, Sentinel, and clustering; this article walks through its evolution from simple caching to high‑availability, distributed architectures, and advanced client features.
This article introduces the main Redis scaling solutions—including simple partitioning, master‑slave replication, Sentinel high‑availability, and Redis Cluster—explaining their concepts, usage patterns, advantages, and drawbacks to help developers choose the appropriate architecture for high‑traffic environments.
This article details the design, deployment, configuration, operation, monitoring, and backup of a PostgreSQL high‑availability cluster built on Patroni, Etcd, and LVS at 360, covering hardware layout, software versions, installation steps, parameter tuning, fail‑over testing, and future outlook.
This article explains how to extend Redis beyond a single instance by covering partitioning, master‑slave replication, Sentinel automatic failover, and Redis Cluster, describing their usage methods, advantages, and drawbacks for high‑traffic, high‑availability scenarios.
This guide compiles nineteen common Kubernetes problems—from certificate errors and service exposure failures to pod initialization issues and Helm installation errors—providing concise root‑cause analyses and step‑by‑step command solutions to help you quickly troubleshoot and resolve cluster disruptions.
This guide walks through selecting a clustering strategy, installing Percona XtraDB Cluster (PXC) with Docker, configuring a five‑node cluster, adding HAProxy for load balancing, testing access, and handling node failures to achieve strong consistency and high availability for critical data.
This article explains how Redis Cluster uses hash slots for data partitioning, enables near‑linear scaling and fault‑tolerant failover through master‑slave replication, and requires client‑side routing support, while discussing the trade‑off between performance and consistency in distributed systems.
This guide explains how to set up a Percona XtraDB Cluster (PXC) using Docker containers, configure five-node replication with strong consistency, and implement HAProxy as a TCP load balancer to achieve high availability and balanced read/write traffic across the cluster.
This article provides a comprehensive overview of Redis interview questions, covering persistence mechanisms, cache avalanche and penetration, hot vs. cold data, differences from Memcached, single‑threaded performance, data structures, internal architecture, expiration policies, clustering options, distributed locks, and transaction handling.
MySQL Group Replication, introduced in 2016, delivers high‑availability, strong consistency, fault‑tolerant and scalable MySQL clusters through a Paxos‑based, plugin‑driven architecture that supports both single‑primary and multi‑primary modes, with detailed installation, configuration, deployment and testing guidance, while noting its limited current adoption due to ecosystem maturity.
This article reviews Redis's latest features and compares various deployment architectures—including single‑replica, dual‑replica, cluster, and read‑write‑separation modes—detailing their reliability, performance characteristics, suitable use cases, and provides a Java Jedis example for configuring a direct‑connect cluster.
This guide presents practical best‑practice configurations for Elasticsearch clusters in production, covering JVM heap sizing, CPU thread‑pool tuning, optimal shard counts, replica strategies, hot‑warm node architecture, node role settings, common troubleshooting tips, cache handling, refresh intervals, and essential monitoring APIs.
In a Redis cluster, bulk MGET calls suffered intermittent latency spikes because keys were distributed across many hash slots, forcing multiple network round‑trips; the issue can be mitigated by grouping keys with a common hash tag (though it reduces HA) or by issuing parallel slot‑wise MGETs with careful tuning, which preserves topology for larger batches.
This article outlines the new features of Redis 6.0 and 5.0, compares various deployment architectures such as master‑replica, single‑replica, cluster and read‑write split, presents typical usage scenarios, and provides a Java Jedis code sample for connecting to a Redis cluster.
This article reviews various cache system types, compares popular distributed caches such as Memcache, Tair, and Redis, explains Redis cluster high‑availability mechanisms, discusses sharding strategies, and outlines common cache problems and solutions, providing practical configuration examples for Java backend developers.
This tutorial walks you through creating four VirtualBox Linux VMs, configuring networking, disabling firewalls, installing Java and Perl, setting up password‑less SSH, and preparing a reusable cluster environment that can later host Redis, Kafka, or Storm clusters.
This article reviews Redis 6.0 and 5.0 new features, compares cluster, master‑replica, and read‑write separation architectures, explains proxy and direct connection modes, and provides Java code for custom connection pools, helping you select the optimal Redis deployment for your workload.
This article provides a detailed tutorial on Nacos, covering its advantages over Eureka, step‑by‑step setup for service registration and discovery, configuration management with dynamic refresh, shared configurations, persistence to MySQL, cluster deployment, and the trade‑offs between CP and AP modes in a cloud‑native microservices environment.
This article outlines the major new features of Redis 6.0 and 5.0, compares various deployment architectures—including master‑replica, cluster, and read‑write separation—explains proxy versus direct connection modes, and provides a Java Jedis connection‑pool code sample.
This article reviews Redis 6.0 and 5.0 new features, compares cluster, master‑replica (single and double replica), and read‑write‑separation architectures, explains their reliability and use‑case scenarios, and provides a Java/Jedis code sample for custom connection‑pool configuration.
This guide walks you through setting up a three‑node etcd cluster on CentOS 7 using static configuration and self‑signed TLS certificates, covering member addition and removal, data backup via snapshots, and full cluster restoration from those snapshots.
