BestHub
Sign in
Tagged articles

Redis

3508 articles · Page 35 of 36
ITPUB
ITPUB
Sep 25, 2016 · Databases

How Redis 2.8 Introduces Partial Replication to Avoid Full Sync on Network Glitches

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.

Partial SyncRedisReplication
0 likes · 11 min read
How Redis 2.8 Introduces Partial Replication to Avoid Full Sync on Network Glitches
dbaplus Community
dbaplus Community
Sep 20, 2016 · Backend Development

Zero‑Intrusion Data Fallback with Nginx + Lua: A Practical Guide

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.

AOPData FallbackLua
0 likes · 11 min read
Zero‑Intrusion Data Fallback with Nginx + Lua: A Practical Guide
MaGe Linux Operations
MaGe Linux Operations
Sep 19, 2016 · Databases

Master Redis Cluster Setup: From Basics to Scaling Nodes

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.

ClusterDatabaseDevOps
0 likes · 11 min read
Master Redis Cluster Setup: From Basics to Scaling Nodes
GF Securities FinTech
GF Securities FinTech
Sep 14, 2016 · Big Data

Scaling Real-Time Stock Market Data with Redis, Lua, and Go Goroutines

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.

LuaParallel ComputingRedis
0 likes · 12 min read
Scaling Real-Time Stock Market Data with Redis, Lua, and Go Goroutines
ITPUB
ITPUB
Aug 21, 2016 · Backend Development

How to Diagnose and Prevent Redis Data Loss in Production

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.

Data lossRedisbackend
0 likes · 11 min read
How to Diagnose and Prevent Redis Data Loss in Production
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Aug 12, 2016 · Databases

Why Redis Replicas Return Expired Keys and How to Prevent It

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.

CacheRedisReplication
0 likes · 9 min read
Why Redis Replicas Return Expired Keys and How to Prevent It
dbaplus Community
dbaplus Community
Aug 12, 2016 · Backend Development

Designing a High‑Performance In‑Memory Cache: Structures, Locks, and Go Concurrency

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.

GoMemoryManagementRedis
0 likes · 20 min read
Designing a High‑Performance In‑Memory Cache: Structures, Locks, and Go Concurrency
Java High-Performance Architecture
Java High-Performance Architecture
Aug 5, 2016 · Databases

5 Essential Redis Tips from Heroku to Boost Performance

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.

Client NamingRedisSCAN
0 likes · 4 min read
5 Essential Redis Tips from Heroku to Boost Performance
Architecture Digest
Architecture Digest
Jul 31, 2016 · Game Development

Maintaining Game World State with Data Services: Architecture, Sharding, and High Availability

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.

Data ServiceRedisgame server
0 likes · 32 min read
Maintaining Game World State with Data Services: Architecture, Sharding, and High Availability
Architect
Architect
Jul 21, 2016 · Databases

Redis Ziplist (Compressed List) Principles and Applications

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.

Data StructuresRedismemory optimization
0 likes · 10 min read
Redis Ziplist (Compressed List) Principles and Applications
Architect
Architect
Jul 3, 2016 · Databases

Understanding Redis Cluster Partitioning Implementation

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.

ClusterKey hashingRedis
0 likes · 10 min read
Understanding Redis Cluster Partitioning Implementation
ITPUB
ITPUB
Jul 2, 2016 · Databases

Understanding NoSQL: Key-Value, Columnar, and Document Databases Explained

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.

ColumnarDocumentMongoDB
0 likes · 8 min read
Understanding NoSQL: Key-Value, Columnar, and Document Databases Explained
ITPUB
ITPUB
Jun 25, 2016 · Operations

Why Large Redis Deployments Fail: Failover, Scaling, and Memory Pitfalls

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.

FailoverRedisScaling
0 likes · 8 min read
Why Large Redis Deployments Fail: Failover, Scaling, and Memory Pitfalls
Java High-Performance Architecture
Java High-Performance Architecture
Jun 24, 2016 · Databases

Boost Redis Performance: Reduce Latency with Multi-Param Commands, Pipelining, and Smart Command Choices

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.

Command LatencyMulti-parameter CommandsPipelining
0 likes · 3 min read
Boost Redis Performance: Reduce Latency with Multi-Param Commands, Pipelining, and Smart Command Choices
Efficient Ops
Efficient Ops
Jun 19, 2016 · Databases

One‑Click Docker Deployment of a Redis Sharding Cluster

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.

ClusterDatabase deploymentDevOps
0 likes · 11 min read
One‑Click Docker Deployment of a Redis Sharding Cluster
21CTO
21CTO
Jun 12, 2016 · Backend Development

Mastering Rate Limiting: Token Bucket, Leaky Bucket, and Real‑World Implementations

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.

GuavaJavaRedis
0 likes · 17 min read
Mastering Rate Limiting: Token Bucket, Leaky Bucket, and Real‑World Implementations
ITPUB
ITPUB
May 25, 2016 · Databases

Mastering Redis Replication: Features, Mechanics, and Deployment Guide

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.

DatabaseMaster‑SlaveRedis
0 likes · 8 min read
Mastering Redis Replication: Features, Mechanics, and Deployment Guide
dbaplus Community
dbaplus Community
May 24, 2016 · Databases

Which NoSQL DB Fits Your Node Project? HBase, Redis, MongoDB, Couchbase, LevelDB Compared

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.

CouchbaseDatabase ComparisonHBase
0 likes · 28 min read
Which NoSQL DB Fits Your Node Project? HBase, Redis, MongoDB, Couchbase, LevelDB Compared
Baidu Maps Tech Team
Baidu Maps Tech Team
May 11, 2016 · Backend Development

Mastering Cache Strategies: When to Use LRU, LFU, and Consistency Techniques

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.

LFULRURedis
0 likes · 10 min read
Mastering Cache Strategies: When to Use LRU, LFU, and Consistency Techniques
Big Data and Microservices
Big Data and Microservices
May 11, 2016 · Backend Development

How to Build a Scalable Flash‑Sale System that Handles Massive Traffic

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.

DatabaseRedisSystem Design
0 likes · 11 min read
How to Build a Scalable Flash‑Sale System that Handles Massive Traffic
21CTO
21CTO
May 10, 2016 · Backend Development

How to Prevent Cache Penetration, Concurrency, and Expiration Issues in Redis and Memcached

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.

Cache ConcurrencyCache PenetrationMemcached
0 likes · 8 min read
How to Prevent Cache Penetration, Concurrency, and Expiration Issues in Redis and Memcached
MaGe Linux Operations
MaGe Linux Operations
Apr 19, 2016 · Databases

How to Set Up a Codis Cluster on Linux with Go: Step‑by‑Step Guide

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.

ClusterCodisGo
0 likes · 11 min read
How to Set Up a Codis Cluster on Linux with Go: Step‑by‑Step Guide
dbaplus Community
dbaplus Community
Apr 13, 2016 · Databases

Secure Redis Cluster: Adding Password Authentication and Automated Node Management

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.

Cluster ManagementData MigrationRedis
0 likes · 8 min read
Secure Redis Cluster: Adding Password Authentication and Automated Node Management
MaGe Linux Operations
MaGe Linux Operations
Apr 2, 2016 · Operations

How to Install GitLab on Debian: Complete Step‑by‑Step Guide

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.

DebianGoInstallation
0 likes · 18 min read
How to Install GitLab on Debian: Complete Step‑by‑Step Guide
21CTO
21CTO
Mar 25, 2016 · Backend Development

How to Share Tomcat Sessions via Redis: Step-by-Step Setup Guide

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.

GradleJavaRedis
0 likes · 8 min read
How to Share Tomcat Sessions via Redis: Step-by-Step Setup Guide
Efficient Ops
Efficient Ops
Mar 22, 2016 · Databases

Scaling PB‑Level Data: Mastering Redis, Codis, and MySQL Sharding

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.

CodisMySQLPB-level Data
0 likes · 15 min read
Scaling PB‑Level Data: Mastering Redis, Codis, and MySQL Sharding
Efficient Ops
Efficient Ops
Mar 15, 2016 · Operations

How to Use Redis for Efficient Deduplication in Operations Data Analysis

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.

HyperLogLogRedisdeduplication
0 likes · 10 min read
How to Use Redis for Efficient Deduplication in Operations Data Analysis
High Availability Architecture
High Availability Architecture
Feb 26, 2016 · Databases

Weibo Database Architecture: Evolution, Optimization, and Design Practices

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.

AutomationData synchronizationDatabase Architecture
0 likes · 23 min read
Weibo Database Architecture: Evolution, Optimization, and Design Practices
21CTO
21CTO
Feb 25, 2016 · Backend Development

Mastering Multi‑Layer Caching in Rails with Nginx, Redis, and MySQL

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.

PerformanceRailsRedis
0 likes · 12 min read
Mastering Multi‑Layer Caching in Rails with Nginx, Redis, and MySQL
21CTO
21CTO
Feb 4, 2016 · Backend Development

How Tumblr Scaled to 5 Billion Page Views: Inside Their Distributed Architecture

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.

FinagleRedisScala
0 likes · 21 min read
How Tumblr Scaled to 5 Billion Page Views: Inside Their Distributed Architecture
Efficient Ops
Efficient Ops
Feb 2, 2016 · Databases

Why Codis Outperforms Twemproxy: A Deep Dive into Redis Cluster Solutions

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.

CodisRedisTwemproxy
0 likes · 11 min read
Why Codis Outperforms Twemproxy: A Deep Dive into Redis Cluster Solutions
Java High-Performance Architecture
Java High-Performance Architecture
Jan 30, 2016 · Databases

Understanding Redis 3 Cluster: Key Concepts, Features, and 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.

ClusterDatabaseHash Slot
0 likes · 4 min read
Understanding Redis 3 Cluster: Key Concepts, Features, and Operations
Qunar Tech Salon
Qunar Tech Salon
Jan 14, 2016 · Databases

Understanding Redis’s Reactor Pattern and I/O Multiplexing

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.

I/O multiplexingReactor patternRedis
0 likes · 12 min read
Understanding Redis’s Reactor Pattern and I/O Multiplexing
Architect
Architect
Jan 11, 2016 · Backend Development

Understanding Redis’s Reactor Pattern and I/O Multiplexing

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.

I/O multiplexingReactor patternRedis
0 likes · 12 min read
Understanding Redis’s Reactor Pattern and I/O Multiplexing
Java High-Performance Architecture
Java High-Performance Architecture
Dec 23, 2015 · Backend Development

Ensuring Safe Redis Queues with RPOPLPUSH and Blocking Commands

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.

Blocking CommandsMessage QueueRPOPLPUSH
0 likes · 4 min read
Ensuring Safe Redis Queues with RPOPLPUSH and Blocking Commands
21CTO
21CTO
Dec 20, 2015 · Backend Development

How Twitter Scales Redis to 105 TB RAM and 39 M QPS

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.

Cluster ManagementRedisTwitter
0 likes · 21 min read
How Twitter Scales Redis to 105 TB RAM and 39 M QPS
Architect
Architect
Dec 14, 2015 · Databases

Redis Cluster: Application Cases, Pros & Cons, and Technical Analysis

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.

ClusterDatabaseRedis
0 likes · 13 min read
Redis Cluster: Application Cases, Pros & Cons, and Technical Analysis
Architect
Architect
Dec 13, 2015 · Databases

Redis Partitioning: How to Store Data Across Multiple Redis Instances

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.

Database ScalingRedisRedis Cluster
0 likes · 11 min read
Redis Partitioning: How to Store Data Across Multiple Redis Instances
dbaplus Community
dbaplus Community
Dec 12, 2015 · Backend Development

How Memcached and Redis Work: Architecture, Protocols, and Memory Management

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.

MemcachedRedisbackend
0 likes · 8 min read
How Memcached and Redis Work: Architecture, Protocols, and Memory Management
Architect
Architect
Dec 12, 2015 · Databases

Understanding Redis Master‑Slave Replication and Its Configuration

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.

ConfigurationDatabaseMaster‑Slave
0 likes · 10 min read
Understanding Redis Master‑Slave Replication and Its Configuration
Architect
Architect
Dec 11, 2015 · Backend Development

Implementing Distributed Locks with Redis: The RedLock Algorithm

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.

RedisRedlockconcurrency
0 likes · 16 min read
Implementing Distributed Locks with Redis: The RedLock Algorithm
21CTO
21CTO
Dec 11, 2015 · Backend Development

From Simple Polling to Scalable Microservices: JD’s Dongdong IM Evolution

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.

IM SystemRedisbackend architecture
0 likes · 11 min read
From Simple Polling to Scalable Microservices: JD’s Dongdong IM Evolution
Architect
Architect
Dec 10, 2015 · Databases

Understanding Redis maxmemory Configuration and Approximate LRU Eviction Policies

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.

LRUMemory ManagementRedis
0 likes · 11 min read
Understanding Redis maxmemory Configuration and Approximate LRU Eviction Policies
21CTO
21CTO
Dec 9, 2015 · Backend Development

How Worktile Built a Scalable MEAN Stack with Real‑Time Messaging

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.

AngularJSMEAN stackNode.js
0 likes · 10 min read
How Worktile Built a Scalable MEAN Stack with Real‑Time Messaging
ITPUB
ITPUB
Dec 4, 2015 · Backend Development

How to Measure and Optimize System Load Capacity for High‑Concurrency Backends

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.

Linux TuningMySQLRedis
0 likes · 19 min read
How to Measure and Optimize System Load Capacity for High‑Concurrency Backends
Java High-Performance Architecture
Java High-Performance Architecture
Dec 3, 2015 · Backend Development

Unlock Real-Time Messaging: How Redis Pub/Sub Works and When to Use It

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.

AsynchronousRedismessaging
0 likes · 4 min read
Unlock Real-Time Messaging: How Redis Pub/Sub Works and When to Use It
Architect
Architect
Dec 2, 2015 · Databases

Redis vs Memcached: Clarifications and Comparative Analysis

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.

Lua ScriptingMemcachedMemory Efficiency
0 likes · 9 min read
Redis vs Memcached: Clarifications and Comparative Analysis
Architect
Architect
Nov 22, 2015 · Backend Development

Implementing Rails Fragment Cache with Redis and Session Storage

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.

CacheFragmentCacheRails
0 likes · 9 min read
Implementing Rails Fragment Cache with Redis and Session Storage
21CTO
21CTO
Nov 19, 2015 · Cloud Computing

How Mango TV Built a Hybrid Cloud Platform to Scale Video Services

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.

DockerRediscloud native
0 likes · 12 min read
How Mango TV Built a Hybrid Cloud Platform to Scale Video Services
21CTO
21CTO
Nov 18, 2015 · Backend Development

How Xiaomi Engineered a High‑Performance Flash‑Sale System for the 2014 Mi Fan Festival

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.

GoRedisbackend architecture
0 likes · 15 min read
How Xiaomi Engineered a High‑Performance Flash‑Sale System for the 2014 Mi Fan Festival
Efficient Ops
Efficient Ops
Nov 11, 2015 · Information Security

Why Redis Unauthorized Access Is a Critical Threat and How to Fix It

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.

Network ExposureRedisSecurity
0 likes · 4 min read
Why Redis Unauthorized Access Is a Critical Threat and How to Fix It
dbaplus Community
dbaplus Community
Nov 11, 2015 · Backend Development

Designing Scalable Flash‑Sale Architecture to Survive Traffic Surges

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.

Redisbackend architectureflash sale
0 likes · 16 min read
Designing Scalable Flash‑Sale Architecture to Survive Traffic Surges
Java High-Performance Architecture
Java High-Performance Architecture
Oct 27, 2015 · Backend Development

How Consistent Hashing Powers Scalable Memcached Clusters

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.

Backend PerformanceMemcachedRedis
0 likes · 2 min read
How Consistent Hashing Powers Scalable Memcached Clusters
Architect
Architect
Oct 24, 2015 · Backend Development

Designing a Complete Distributed Server Cluster Architecture for Large Websites

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.

HAProxyRedisdistributed systems
0 likes · 8 min read
Designing a Complete Distributed Server Cluster Architecture for Large Websites
Architect
Architect
Oct 23, 2015 · Databases

Designing KV Schemas with Redis: Login System and Tag System Examples

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.

Database ComparisonKey-Value DesignRedis
0 likes · 9 min read
Designing KV Schemas with Redis: Login System and Tag System Examples
21CTO
21CTO
Oct 20, 2015 · Backend Development

Scaling a Web System to 100M Daily Visits: Load Balancing, Caching, and Architecture

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.

MySQLRedisWeb Scaling
0 likes · 21 min read
Scaling a Web System to 100M Daily Visits: Load Balancing, Caching, and Architecture
Efficient Ops
Efficient Ops
Oct 12, 2015 · Operations

Redis Cluster Migration Lessons: Real‑World Failures and Practical Solutions

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.

ClusterRedisSmart Proxy
0 likes · 13 min read
Redis Cluster Migration Lessons: Real‑World Failures and Practical Solutions
21CTO
21CTO
Oct 1, 2015 · Backend Development

How to Scrape 1.1 Million Zhihu Users with PHP cURL, Multi‑Threading, and Redis

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.

Multi‑processingMySQLPHP
0 likes · 15 min read
How to Scrape 1.1 Million Zhihu Users with PHP cURL, Multi‑Threading, and Redis
Architect
Architect
Sep 26, 2015 · Databases

Architectural Challenges and Optimization Strategies for Redis Cluster

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.

ClusterRedisarchitecture
0 likes · 17 min read
Architectural Challenges and Optimization Strategies for Redis Cluster
21CTO
21CTO
Sep 23, 2015 · Backend Development

How to Tackle 50k QPS Flash Sales: Backend Strategies for Extreme Concurrency

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.

Redisbackend optimizationflash sale
0 likes · 16 min read
How to Tackle 50k QPS Flash Sales: Backend Strategies for Extreme Concurrency
Architect
Architect
Jul 30, 2015 · Backend Development

Technical Architecture of Worktile: SPA Design, Service Stack, and Real-time Messaging

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.

AngularJSMongoDBNode.js
0 likes · 11 min read
Technical Architecture of Worktile: SPA Design, Service Stack, and Real-time Messaging
Architect
Architect
Jul 30, 2015 · Backend Development

Redis‑Backed Timeline Implementation with MongoDB for a Subscription Feed

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.

CacheMongoDBQueue
0 likes · 7 min read
Redis‑Backed Timeline Implementation with MongoDB for a Subscription Feed
Efficient Ops
Efficient Ops
Jun 17, 2015 · Cloud Native

Project Eru: Scaling a Custom Docker Orchestration Platform to 10k Nodes

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.

Container OrchestrationMacvlanRedis
0 likes · 22 min read
Project Eru: Scaling a Custom Docker Orchestration Platform to 10k Nodes
High Availability Architecture
High Availability Architecture
May 24, 2015 · Cloud Native

Design and Implementation of Project Eru: A Docker‑Based Cloud Native Scheduling Platform at Mango TV

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.

Container OrchestrationDockerMacvlan
0 likes · 24 min read
Design and Implementation of Project Eru: A Docker‑Based Cloud Native Scheduling Platform at Mango TV