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.
The article explains the publish‑subscribe (pub/sub) messaging model, its time, space, and synchronization decoupling features, typical real‑time scenarios such as chat and log processing, and details how Redis implements pub/sub through channels and pattern subscriptions, including command syntax and internal data structures.
This article critically examines common claims that Memcached is superior for caching by comparing its design, threading, disk I/O, memory efficiency, LRU behavior, smart caching features, persistence, replication, observability, and Lua scripting capabilities against Redis, concluding that the two systems have distinct trade‑offs depending on use case.
This article details a backend redesign of an instant‑messaging platform, covering Java interfaces for unread messages, Redis‑based unread counters, persistent queue processing, MySQL sharding and partitioning, SQL retrieval logic, and performance tuning to achieve high insert throughput.
This article explains how to enable Rails fragment caching, use HTML fragment cache helpers, understand cache digests, observe read/write fragment logs, and migrate the cache store from file system to Redis by adding redis-namespace and redis-rails gems, configuring cache_store, and handling cache invalidation on data changes.
This article details a deep‑rooted Redis replication bug where slave offsets become larger than the master after a network interruption, explains the underlying cause in the full‑sync process, describes the code changes made to fix it, and offers testing and prevention guidance.
The article examines how Mango TV leveraged its broadcast assets and a hybrid cloud architecture—combining private and public cloud services, Docker‑based scheduling, Redis‑Cluster, and a custom PaaS called ProjectEru—to support IPTV, OTT, and web content at massive scale while maintaining stability and low operational cost.
This article details Xiaomi's step‑by‑step design and evolution of its flash‑sale platform, covering the initial PHP‑Redis solution, the challenges of extreme concurrency, and the later Go‑based architecture that enabled millions of users to purchase smartphones reliably during the 2014 Mi Fan Festival.
The article explains that Redis’s default public binding and lack of authentication allow attackers to read data, execute code, and write their SSH public key into /root/.ssh/authorized_keys, providing a complete guide to exploitation, statistical impact, PoC code, and practical mitigation measures.
This article explains a high‑severity Redis unauthorized‑access vulnerability that can let attackers write SSH keys to the host, highlights the risk of exposing Redis to the Internet without authentication, and provides guidance on remediation and network protection.
This article explains how to design a high‑availability flash‑sale system by separating business and data layers, using Redis queues for pressure isolation, ensuring inventory consistency, handling transaction reconciliation, and addressing anti‑fraud measures to cope with massive concurrent traffic.
Caching dramatically improves website performance by storing data in memory for faster responses and reducing database load, with Memcached and Redis as popular solutions; proper routing algorithms like consistent hashing are essential to scale clusters without causing cache misses or service disruption.
This article outlines a comprehensive distributed server cluster architecture for large‑scale websites, covering the evolution from simple three‑tier setups to high‑availability load‑balancing with HAProxy/Keepalived, Redis caching, NoSQL storage, and future distributed MySQL considerations.
The article explains how Redis's rich data structures enable flexible key‑value schema designs for a user login system and a tag system, contrasting them with traditional relational database approaches and demonstrating practical commands and Python code for common operations.
This article explains how a web system can grow from 100,000 to 100 million daily visits by introducing multi‑level caching, various load‑balancing strategies, MySQL performance tuning, distributed database setups, and geographic deployment to maintain stability and performance under massive traffic.
This article recounts a series of July Redis incidents—including network‑card saturation, connection‑limit exhaustion, suspected split‑brain, Bgsave‑induced OOM, and master‑restart data loss—detailing the migration to Redis Cluster with a Smart Proxy, the challenges faced, and actionable remediation strategies.
This tutorial walks through collecting over a million Zhihu user profiles using PHP on Ubuntu, handling cookies, bypassing image hot‑link protection, scaling requests with curl_multi, de‑duplicating MySQL inserts, and coordinating work with Redis and multi‑process pcntl for efficient large‑scale web scraping.
The article analyzes the inherent drawbacks of Redis Cluster—such as its decentralized P2P design, gossip overhead, upgrade difficulty, lack of hot‑cold data separation, client protocol challenges, and implementation limits—and proposes architectural enhancements like proxy, dashboard, and agent components to improve scalability, manageability, and performance.
This article explores the challenges of handling tens of thousands of requests per second in flash‑sale systems, covering interface design, QPS calculations, overload protection, anti‑cheat measures, and data‑safety techniques such as pessimistic, optimistic, and queue‑based locking.
This article explains the concepts of Single Sign‑On and Message Queues, outlines their business scenarios, core elements, and simple implementation approaches in J2EE, and provides a concrete Spring‑Redis example with configuration and listener code.
Worktile’s architecture combines a single‑page AngularJS front‑end with a Node.js/Express backend, leveraging MongoDB, Redis, and ejabberd for real‑time messaging, illustrating how SPA design, modular services, and long‑connection techniques enable a stable, high‑performance team collaboration platform.
This article explains how to implement a scalable timeline for a subscription feed by combining MongoDB storage with a Redis list cache, detailing the data model, query challenges, Redis operations for pushing and trimming statuses, rebuilding strategies, and handling data integrity trade‑offs.
This article explains the motivations behind key‑value stores, compares Redis with the newly created QDB, and details the architecture, dynamic resharding, high‑availability mechanisms, and future improvements of the distributed database solution RebornDB.
This article presents an in‑depth overview of Codis and its next‑generation project RebornDB, covering Redis, Redis Cluster, the proxy‑based architecture, consistency trade‑offs, production deployment experiences, operational pitfalls, and broader perspectives on distributed databases and architectures.
The article explains how Worktile achieves cross‑platform web access, native‑like SPA experience, real‑time messaging, and service stability by using AngularJS for the frontend, Node.js, Redis, MongoDB, and ejabberd/XMPP for backend and push services.
Due to the memory limits of single Redis servers, many companies adopt proxy‑based Redis clustering solutions such as Netflix’s Dynomite, Twitter’s Twemproxy, and the open‑source Codis from Wandoujia, which provide distributed caching, cross‑data‑center replication, and improved performance and availability.
This guide explains how to reshard a Redis cluster by moving hash slots between nodes, detailing each command-line step, required inputs, and verification procedures to ensure balanced slot distribution across the cluster.
Project Eru, a homegrown Docker‑based orchestration system developed at Mango TV, replaces earlier PaaS attempts with a stateless, scalable core and agent architecture, leveraging Redis clusters, MacVLAN networking, and fine‑grained CPU allocation to achieve rapid, automated scaling across thousands of containers.
This article compares static file serving and Redis‑based page caching for heavily visited sites, outlining their advantages and drawbacks such as speed, update frequency, database load, implementation complexity, and the need for dynamic processing.
This guide explains how to use Redis's built‑in redis-benchmark tool to measure the throughput of local or remote Redis instances, covering basic testing, selective command benchmarking, and remote server testing with practical command examples.
The article recounts the evolution from Douban's App Engine to Mango TV's Nebulium Engine and finally Project Eru, describing how Docker, Redis Cluster, MacVLAN networking, and custom resource scheduling were combined to build a scalable, cloud‑native platform for heterogeneous workloads.
Disque, an open‑source distributed in‑memory message broker created by Redis's creator, offers synchronous replication, flexible delivery semantics, multi‑master clustering, and fine‑grained job control, but remains in Alpha with several limitations that make it unsuitable for production use today.
This article reviews common Redis clustering methods, compares Twemproxy and Codis, presents Codis’s architecture and performance test results, and offers migration, HA, pipeline, and operational guidance for using Codis as a Redis distributed middleware solution.
This article examines how popular caching systems such as Redis, Memcached, Guava Cache, and Ehcache implement eviction policies like LRU, LFU, and FIFO, comparing their algorithmic approaches, code implementations, and expiration handling mechanisms.
This article examines common NoSQL key‑value stores such as Memcached and Redis, compares their strengths and limitations, and proposes a distributed architecture with routing, storage, management, and migration nodes that achieves high availability, automatic fault‑tolerance, load balancing, and elastic scaling.
This article explains the security risks surrounding Redis, covering access control, authentication, command renaming, network exposure, and code‑execution vulnerabilities, and provides practical configuration steps to protect a Redis deployment from common attacks.
The author recounts a real‑world incident where consolidating many Redis GET calls into a single MGET reduced network latency but unexpectedly increased overall response time, leading to timeout errors; they detail the investigation using Redis slowlog, code analysis, and proper pagination techniques to resolve the hidden performance bottleneck.
This guide presents a comprehensive collection of Redis configuration directives, covering daemonization, networking, persistence, replication, security, memory management, AOF, Lua scripting, slow log, event notifications, and advanced tuning options, enabling administrators to optimize performance, reliability, and safety of their Redis deployments.
This article compares Redis with MySQL, outlines their similarities and differences, examines Redis alongside Memcached, EhCache, and OSCache, and proposes a simple high‑availability architecture for Redis, highlighting performance, data model, scalability, and operational considerations.
This article reviews the five core Redis data structures—String, Hash, List, Set, and Sorted Set—detailing practical use‑cases such as caching, user profile storage, timelines, message queues, social graphs, and weighted rankings, plus a look at Pub/Sub and transaction features.
At Baidu’s 49th Technical Salon, Cheng Yishi explained how the company revamped its MooseFS and Redis systems by adding a Shadow Master to split reads from writes, introducing Slave nodes for failover, and deploying a Redis proxy middleware, thereby dramatically improving performance, scalability, and high‑availability for critical services.
