This article explains Redis as an open‑source in‑memory data store, compares its main deployment modes—single instance, Redis Cluster, and Redis Sentinel—detailing their architectures, replication, sharding, failover mechanisms, client options, and backup strategies such as RDB and AOF.
Redis is an open-source, in‑memory data structure store offering high‑performance caching, persistence, replication, and rich data types such as strings, lists, sets, hashes, and sorted sets, and this guide compares its strengths and differences with Memcached and other databases.
This article explains the inner workings of Spring Session with Redis, detailing how web.xml configuration, DelegatingFilterProxy, and the springSessionRepositoryFilter collaborate to replace the default HttpSession, wrap requests and responses, and enable distributed session sharing in a Java backend environment.
This article reviews recent ransomware campaigns targeting MySQL, MongoDB, ElasticSearch, Hadoop, and Redis, explains how attackers exploit weak password policies, and provides concrete MySQL password‑policy settings, password‑less login configuration, and security checklists for multiple database platforms.
This article explains the architecture, real‑time computation framework, and storage solutions of Tencent Analytics, detailing how massive TB‑level web‑traffic data are collected via JavaScript, processed in memory‑centric streaming components, and stored using Redis and LevelDB to achieve second‑level updates.
This guide explains how to replace Tomcat's default HttpSession with Spring Session backed by Redis, covering load‑balancing challenges, configuration steps, common pitfalls, and a complete XML‑based example for building a scalable distributed web application.
This guide walks through the complete installation, configuration, and integration of the ELK stack components—Logstash, Redis, Elasticsearch, and Kibana—providing command‑line examples, configuration snippets, testing procedures, and visual verification using Kibana and the Kopf plugin.
This article compares Memcached and Redis, evaluating their architectures, performance, scalability, persistence, and suitable use cases for handling tens of millions of database rows with high‑speed caching and in‑memory data storage.
A developer recounts how a Redis connection pool overflow across dozens of clusters was traced to a single misbehaving service, diagnosed with netstat and ps commands, and resolved by adjusting configuration and stopping the offending process, illustrating practical troubleshooting of connection limits.
This guide explains what Twemproxy is, its features and limitations, and provides step‑by‑step instructions for installing, configuring, and testing the proxy with two Redis instances, plus high‑availability strategies using HAProxy and Sentinel.
This article explains Redis's LRU eviction mechanism, starting with a brief LRU overview, presenting a Python LRU cache implementation, then detailing Redis's internal LRU clock, object fields, maxmemory policies, and both active and passive eviction processes, highlighting configuration impacts on performance.
This article explains Redis fundamentals, its key‑value storage model, advanced data structures, persistence mechanisms (RDB and AOF), replication architecture, and how Sentinel provides automated failover and high‑availability management, complemented by practical configuration examples and performance considerations.
This article examines the MySQL‑Memcached architecture, explains Memcached’s slab memory management, compares Redis and Memcached across performance, memory efficiency, persistence and data structures, details Redis’s core data types and their internal implementations, and showcases practical use‑cases such as caching, ranking, queues, Pub/Sub and real‑time analytics.
This article explores how a web system can evolve from handling 100,000 daily visits to over 100 million by implementing multi‑layered load‑balancing strategies, optimizing MySQL with indexing and connection pooling, leveraging Redis and cache clusters, and employing geographic distribution and disaster‑recovery techniques to ensure performance and reliability.
The article dissects Redis’s architecture by examining its single‑threaded reactor network model, core data structures and memory‑management tactics, AOF/RDB persistence mechanisms, and master‑slave, Sentinel, and Cluster multi‑node strategies, highlighting how each design choice balances speed, memory usage, and system complexity.
This article summarizes the most recent releases of major NoSQL and NewSQL databases—including MongoDB 3.4, Redis 3.0/3.2, HBase 1.2.4, Apache Geode 1.0, TiDB RC1, and the final update of RethinkDB—highlighting key new capabilities, performance improvements, and operational enhancements.
This guide walks through the fundamentals, installation steps, configuration details, and Python integration for three essential backend services—Memcached for high‑performance caching, Redis for persistent key‑value storage, and RabbitMQ for reliable messaging—complete with command‑line examples, code snippets, and best‑practice tips.
This article summarizes common Redis cache update problems, compares four update approaches—including proactive, passive, and pre‑loading methods—and recommends a pre‑load strategy with key versioning to avoid data loss, improve performance, and reduce memory waste.
This article reviews the evolution of distributed locking—from simple MySQL table locks to Redis cache locks and the Redlock algorithm—examines expert criticisms of Redlock’s correctness, presents the Redis author’s rebuttal, and ultimately recommends Zookeeper as a more reliable solution for high‑availability distributed locks.
This article provides a comprehensive, source‑code‑driven walkthrough of the Redis client‑server interaction, detailing the six main steps from socket establishment to command execution and response, while also covering auxiliary mechanisms such as beforeSleep processing, key expiration strategies, and the underlying epoll I/O multiplexing model.
This article examines Tencent Analytics' architecture, detailing its real-time data collection, in‑memory computation, and NoSQL storage strategies that enable second‑level updates for terabyte‑scale web traffic.
This article examines the operational challenges of oversized Redis instances—including slow failover, prolonged slave resynchronization, network‑induced avalanches, and persistence blocking—and offers practical mitigation strategies such as key expiration, data compression, and using high‑performance alternatives like Pika.
This guide walks you through configuring a simple Redis master‑slave setup, covering the benefits, step‑by‑step file modifications, essential replication directives, testing procedures, and common pitfalls to ensure high availability and read/write separation.
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.
The article explains how insecure serialization in message‑queue middleware, especially Python's pickle used by Celery, can be abused to inject malicious payloads that trigger remote code execution on distributed workers, and it demonstrates detection and exploitation techniques against vulnerable Redis and MongoDB brokers.
This article provides a detailed comparison of Memcached and Redis by examining their service models, event loops, memory allocation strategies, database structures, persistence mechanisms (RDB and AOF), transaction support, and publish‑subscribe features, highlighting the design choices, trade‑offs, and implementation nuances of each key‑value caching system.
This article explains how Hulk’s private‑cloud platform customizes SaltStack for large‑scale command execution, detailing its three‑layer architecture, Redis‑based data flow, and a seven‑step workflow that achieves 99 % success while highlighting current limitations and future improvements.
This article explains Redis's five primary data types—String, Hash, List, Set, and Sorted Set—detailing their commands, use‑cases, internal encodings, memory‑saving configuration parameters, and the available persistence strategies, while offering practical recommendations for production deployments.
This article explains Redis's five core data types, their internal representations and typical commands, details memory‑saving parameters for each type, compares the four persistence methods with their trade‑offs, and offers practical recommendations for optimal performance and stability.
This article explains the design of JD’s flash‑sale (抢购) system, covering its business model, core Redis‑based inventory management, Lua scripting for atomic stock deduction, rate‑limiting, asynchronous logging with JMQ, and fail‑over strategies to ensure high‑concurrency reliability.
The article examines how distributed systems face mutual‑exclusion and idempotency challenges, explains traditional thread and process synchronization, then details distributed‑lock techniques (e.g., Zookeeper, Redis, Tair, Cerberus) and global‑ID‑based idempotent services, emphasizing the importance of external storage, fault‑tolerance, and proper lock granularity for reliable high‑throughput applications.
This article reviews Redis's native limitations, explains three clustering approaches—client‑side sharding, proxy sharding (e.g., Twemproxy), and the official Redis Cluster—then compares Twemproxy's drawbacks and introduces Codis as a modern, open‑source alternative with practical deployment tips.
This article explains Redis’s master‑slave replication mechanism, compares the full‑copy process of Redis 2.4.16 with the partial‑copy improvements introduced in Redis 2.8, details the state machine, replication‑cron workflow, repl_backlog buffer, run‑id handling, and configuration options for optimizing partial synchronization during network interruptions.
Discover how 360’s private cloud platform leverages SaltStack’s Syndic architecture and a Redis Pub/Sub bridge to efficiently manage and execute commands across tens of thousands of servers, addressing multi‑datacenter challenges, reducing message loss, and improving automation performance.
This article explains how to design a robust, zero‑intrusion data fallback component for high‑traffic web services using Nginx, Lua, and AOP principles, covering problem definition, architectural options, detailed execution steps, configuration snippets, storage choices, and performance monitoring.
Learn how to build and manage a Redis cluster on Linux, covering the rationale for clustering, hash slot mechanics, node configuration, adding/removing nodes, resharding, and integrating master‑slave replicas, with step‑by‑step commands and practical examples.
This guide explains how to interpret Redis INFO output, monitor client connections, memory usage, persistence stats, replication CPU metrics, configure eviction policies, understand the LRU algorithm, and perform performance analysis to keep your Redis instance healthy and efficient.
Exploring how a securities firm processes billions of daily stock‑market indicators in real time, this article compares an in‑process Redis + Lua solution with an out‑of‑process Goroutine‑based architecture, detailing data flow, performance trade‑offs, and scalability considerations for high‑frequency time‑series workloads.
This article examines common causes of Redis data loss, walks through a real‑world incident where 90,000 keys vanished, and provides concrete monitoring, configuration, and operational safeguards to detect and avoid such failures.
This article details Zhejiang Mobile's architecture and practical experience in building a billion‑scale real‑time stream computing platform using Storm, Kafka, Flume, and Redis, covering use cases, system design, performance bottlenecks, optimization techniques, and monitoring strategies.
This article explains how JD.com designs a multi‑layer data storage architecture—using MySQL for core metadata, HBase and MongoDB for comment text, Solr/Elasticsearch for indexing, and Redis for caching—to handle billions of daily review requests with high performance and availability.
The article explains how Redis replicas can return keys that should have expired due to the master‑only expiration process, describes the three expiration strategies (lazy, periodic, active), and offers practical solutions such as using SCAN or upgrading to Redis 3.2 to avoid stale reads.
This article explores the fundamentals of building a high‑performance in‑memory cache, covering the relationship between caches and KV stores, various cache types, core data structures such as hash tables, lock strategies, rehash techniques, memory management, and network models, with practical examples and Go‑based concurrency designs.
Heroku shares five practical Redis recommendations—including using connection pools, naming clients, selecting key eviction policies, avoiding the KEYS command, and configuring connection timeouts—to improve performance, manage resources, and simplify troubleshooting in production environments.
This article examines how to maintain game world state using data services, discussing traditional DB proxy processes, the role of Redis as a cache and database, stateless versus stateful services, sharding, high‑availability mechanisms such as Sentinel, Zookeeper, and the overall architecture for scalable MMO back‑ends.
This article explains Redis’s ziplist (compressed list) memory layout, detailing its overall encoding, node structure—including previous length, encoding, and content fields—illustrates how various Redis data types employ ziplist encoding, and analyzes the benefits and trade‑offs of using this structure.
This article compares Redis and Memcached across data‑type support, memory‑usage efficiency, performance, memory‑management mechanisms, persistence options, and clustering capabilities, highlighting the strengths and trade‑offs of each in‑memory data store.
This article explains how Redis Cluster automatically distributes data across nodes, how clients locate the correct node using slot hashing and hash tags, and how resharding and slot migration are performed without downtime, providing a detailed overview of the partitioning mechanism.
An overview of NoSQL database types—including key‑value stores like Redis, column‑oriented systems such as BigTable and HBase, and document databases like MongoDB—covers their architectures, strengths, typical use cases, and key factors to consider when selecting a NoSQL solution for web applications.
The article examines how oversized Redis instances cause catastrophic failures during primary node crashes, scaling bursts, and network issues, explains the costly re‑synchronization steps, presents real‑world timing data, and offers practical memory‑reduction strategies to keep Redis operations reliable.
This article explains how Redis' single‑threaded nature can cause latency and offers three optimization strategies—reducing network I/O, shortening command queues, and cutting execution time—through multi‑parameter commands, pipelining, and avoiding costly operations.
This article reviews three open‑source Redis cache clustering approaches—Netflix's Dynomite, Twitter's Twemproxy, and Wandoujia's Codis—explaining their architectures, advantages, licensing, and suitability for production environments as alternatives to the native Redis cluster feature.
This guide explains how to build Docker images, configure Redis, and orchestrate containers to create a fully automated, one‑click Redis sharding cluster, covering preparation, scripting, configuration, and verification steps.
This article explains why caching, degradation, and rate limiting are essential for high‑concurrency systems, details token‑bucket and leaky‑bucket algorithms, shows application‑level, distributed, and edge‑level throttling techniques, and provides practical Java, Guava, Redis‑Lua, and Nginx‑Lua code examples.
Redis Labs introduces the Redis Module System, enabling developers to extend Redis with C‑based modules that provide advanced features such as in‑database image processing via GraphicsMagick and enhanced string operations like CHECKAND and PREPEND, fostering a growing ecosystem of shared modules.
Redis 3.2 introduces a concise GEO API that lets you store geographic points, perform radius queries, retrieve distances, and manage location data using commands like GEOADD, GEORADIUS, GEORADIUSBYMEMBER, GEODIST, and ZRANGE, while highlighting its underlying sorted‑set storage model.
Redis replication offers high‑availability through master‑slave syncing, supporting multiple slaves, cascading replication, non‑blocking data transfer, read‑write separation, and optional disk‑less sync, with detailed steps for configuration, safety considerations, partial resynchronization, and practical deployment examples.
This article provides a detailed comparison of five popular NoSQL databases—HBase, Redis, MongoDB, Couchbase, and LevelDB—covering their data models, performance characteristics, CAP classification, Node.js client options, advantages, drawbacks, and ideal use‑cases to help developers choose the right storage solution for a new Node project.
This article explains why caching is essential for high‑performance data retrieval, compares LRU and LFU eviction policies, presents three Redis‑based cache implementations, and discusses consistency challenges and solutions such as eviction ordering, consistent hashing, and delayed eviction in distributed systems.
This article analyzes flash‑sale (抢购) business scenarios, outlines a layered architecture separating business and data layers, explains decoupling front‑end pressure, uses Redis‑based queues and caching to manage high‑frequency inventory checks, and describes multi‑party reconciliation mechanisms to ensure reliable stock consistency under extreme load.
This article explains the three common cache problems—penetration, concurrency, and expiration—illustrates why they occur in high‑traffic systems, and provides practical techniques such as pre‑setting placeholder values, locking, and randomizing TTLs to keep databases healthy.
This article provides a comprehensive, step‑by‑step tutorial for installing Go 1.4, compiling Codis from source, configuring Zookeeper, setting up Codis server, proxy, and dashboard, and deploying a three‑node Codis cluster on Linux, including all necessary environment variables and command examples.
This guide explains why the official Redis Cluster tools lack password support, outlines the security risks of an unauthenticated cluster, and introduces a custom management utility that adds password authentication, automates slot migration, and simplifies adding or removing nodes, complete with step‑by‑step testing procedures.
This guide walks through the complete installation of GitLab on a Debian system, covering package installation, Ruby and Go setup, system user creation, database configuration, Redis setup, cloning the source, configuring GitLab, initializing the database, and starting the service.
Redis’s hash‑max‑ziplist‑entries and hash‑max‑ziplist‑value settings control when hash tables switch to compressed ziplist storage, and by segmenting data into 1,000‑item hash tables, Instagram reduced memory usage from ~20 GB to about 5 GB, dramatically improving efficiency.
A benchmark on a test server comparing Redis and SSDB using one million SET, GET, HSET, and HGET requests with 1,000 concurrent clients shows SSDB delivering far lower QPS than Redis, contradicting the performance figures advertised by SSDB.
This tutorial walks through configuring Redis for Tomcat session sharing on Windows, covering environment setup, Gradle compilation of the tomcat-redis-session-manager plugin, jar deployment, context.xml configuration, and verification of shared session IDs across multiple Tomcat instances.
In this technical share, the operations director explains how his team tackled PB‑scale data challenges by scaling Redis with Codis, implementing multi‑dimensional MySQL sharding, using vertical and horizontal partitioning, and optimizing storage with TokuDB, offering practical insights for high‑throughput system design.
This article explains practical methods for deduplicating and counting data in operational analytics using Redis, covering SET, ZSET, BITSET, HyperLogLog, and Bloom filter structures, their advantages, limitations, and suitable scenarios for real‑time and large‑scale metric calculations.
When Redis reaches its maxmemory limit, it can use one of six eviction policies—volatile‑lru, allkeys‑lru, volatile‑random, allkeys‑random, volatile‑ttl, or noeviction—to decide which keys to remove, with defaults and configurable sampling influencing performance and accuracy.
This article explains how to receive immediate notifications when new items are added to a Redis set by leveraging a blocking list as a helper, avoiding polling and implementing a producer‑consumer pattern with atomic transactions.
This article details the evolution of Weibo's database platform—from its early single‑master design through rapid scaling, vertical and horizontal sharding, automation, Redis enhancements, custom middleware, and future plans—offering practical insights into high‑availability, high‑performance data engineering for large‑scale social media services.
This article explains six practical caching strategies—from client‑side HTTP 304 handling to Nginx static caching, full‑page, fragment, query, and database caches—using Ruby on Rails, Nginx, MySQL, and Redis to dramatically improve web application performance.
A benchmark comparing Redis performance with and without the MONITOR command shows a substantial drop in throughput—up to 53% for SET operations—highlighting that MONITOR should be used only for short‑term debugging, as illustrated by a real‑world Meituan case study.
This guide explains how to use Redis's SET command with NX and EX options to create a simple resource lock, including token generation, lock acquisition, automatic expiration, and safe unlocking with DEL after token verification, while warning against using this method for production distributed locks.
Redis’s MONITOR command turns a client into a real‑time debugger, streaming every server‑executed command with timestamps, client info, and arguments, enabling you to identify hot keys, frequent operations, and traffic patterns by analyzing the captured output.
This article explains how Redis Lua scripting can make operations faster, cut network overhead, guarantee atomic execution, and enable script reuse, and it provides practical examples including a simple hello‑world script and a URL‑shortening implementation.
This article examines how Tumblr handled rapid growth—processing 5 billion daily page views, 40 k requests per second, and terabytes of data—by evolving from a LAMP stack to a Scala‑based, Finagle‑driven distributed system with HBase, Redis, Kafka, and a cell architecture that supports massive real‑time dashboards.
This article examines Redis clustering techniques, compares client‑side sharding, proxy sharding, and Redis Cluster, critiques Twemproxy's limitations, and presents Codis's architecture, performance benchmarks, and practical tips for seamless migration and high‑availability in modern operations.
Redis 3 now officially supports clustering, introducing hash slots and dynamic node management to simplify key distribution, scaling, and fault tolerance, allowing seamless read/write operations across multiple nodes without manual hashing, and offering features like online node addition, automatic slave monitoring, and performance‑aware key allocation.
This article explains how Redis, a high‑performance in‑memory database, uses a single‑process single‑thread architecture combined with the Reactor pattern and I/O multiplexing techniques such as select, poll, epoll, and kqueue to efficiently handle massive client connections.
This article explains how Redis, a single‑process single‑threaded in‑memory database, uses the Reactor pattern and various I/O multiplexing techniques such as select, poll, epoll, and kqueue to efficiently handle thousands of concurrent client connections.
This article examines how Dragonfly, a Node.js‑based source site for Taobao's CMS, achieves high stability through thoughtful system design, robust implementation, comprehensive testing, and effective logging and monitoring practices across CDN, Redis, and other dependencies.
Learn how to handle high‑concurrency log collection by buffering logs in a Redis queue, then periodically batch‑inserting them into a database, with code examples for enqueuing, processing, error rollback, and scheduling the task.
This article explains three ways to add priority handling to Redis queues—using a single list with head insertion, employing separate high‑ and normal‑priority lists with BRPOP, and leveraging score keys with sorting—detailing their advantages, drawbacks, and practical Redis command examples.
Redis lists enable simple message queues, but using LPOP/RPOP can lose messages if a consumer crashes; employing the atomic RPOPLPUSH (or its blocking BRPOPLPUSH) command safeguards delivery, and choosing blocking over non‑blocking operations reduces wasted polling and improves resource efficiency.
This article summarizes Yao Yu's "Scaling Redis at Twitter" talk, detailing why Twitter chose Redis, the massive memory and QPS requirements, custom data models, Hybrid List and BTree extensions, cluster management, and operational lessons for building a high‑performance caching service.
This article reviews real‑world Redis Cluster deployments from Youdao, Qihoo 360 and Mango TV, analyzes its architectural drawbacks, client challenges, implementation limitations, performance impact, and summarizes the overall advantages and disadvantages of using Redis Cluster as a distributed database solution.
Redis allocates a dedicated output buffer for each client—whether a regular user, slave, monitor, or Pub/Sub subscriber—and employs size and duration limits to automatically close connections when buffers grow too large, thereby preventing memory exhaustion and potential system crashes.
This article explains the concept, benefits, methods, and practical considerations of partitioning data across multiple Redis instances, covering range and hash partitioning, consistent hashing, implementation options, drawbacks, and recommended tools such as Redis Cluster and Twemproxy.
This article breaks down the core architecture, request protocols, and memory management mechanisms of Memcached and Redis, comparing their server models, highlighting their strengths and trade‑offs, and offering practical guidance for selecting and tuning these distributed caching solutions.
This article explains how Redis master‑slave replication works, covering asynchronous copying, partial resynchronization, disk‑less replication, safety considerations when persistence is disabled, read‑only slaves, authentication, and configuration options such as slaveof and write‑restriction based on slave count.
This article explains how attackers generate an SSH key pair, use an unsecured Redis server to store the public key, modify Redis's working directory and filename settings, and ultimately create an authorized_keys file on the target system to achieve password‑less SSH login.
This article explains how to build reliable distributed locks using Redis, introduces the official RedLock algorithm, discusses safety properties, compares it with simple failover approaches, and provides implementation details, performance considerations, and lock‑extension techniques.
This article chronicles the architectural journey of JD’s Dongdong instant‑messaging platform, detailing its early simple polling design, subsequent performance and scalability challenges, and the progressive shifts toward service‑oriented, micro‑service, and cloud‑native architectures that support massive user growth.
Redis provides a configurable maxmemory setting to limit memory usage, and offers several eviction policies—including allkeys‑lru, volatile‑lru, and random strategies—implemented via an approximate LRU algorithm whose behavior can be tuned with maxmemory‑samples, allowing administrators to balance performance and memory reclamation.
This article explains how Worktile’s team collaboration platform combines a single‑page AngularJS front‑end with Node.js, Redis, MongoDB, and ejabberd XMPP services to achieve cross‑platform access, native‑like interactions, and high‑performance real‑time updates for over 100,000 teams.
This article details a Redis replication bug where slave offsets exceed the master after network interruptions, explains the root‑cause analysis of offset handling during full and incremental sync, describes the code fix applied by the Redis team, and offers testing and prevention guidance.
This guide explains how to secure Redis by configuring trusted IP bindings, enabling strong password authentication, and renaming or disabling dangerous commands, while also emphasizing the need for external safeguards such as firewalls and avoiding default ports.
This guide explains key metrics, influencing factors, and practical tuning steps—including bandwidth, hardware, OS limits, TCP parameters, and server configurations—to assess and improve a backend system's maximum request handling capacity under high concurrency.
