In this interview, Redis China User Group chair Zhang Donghong shares the database’s key features, version history, data types, high‑availability options, clustering mechanics, automation challenges, future trends, and practical advice for beginners, illustrating how Redis powers massive online services.
This guide provides step‑by‑step instructions for securing Redis with a password, recovering MySQL master‑slave replication, redirecting HTTP to HTTPS in Nginx, defending Linux servers against attacks, configuring Zabbix monitoring for MySQL, and various Nginx and MySQL configuration tricks.
This document provides a comprehensive step-by-step guide to installing and configuring Redis on Linux and macOS, covering package download, compilation, service setup, and operational configuration.
This article explains how to correctly configure JedisPool and its underlying GenericObjectPoolConfig, provides Maven dependency details, demonstrates pool initialization and usage patterns, and offers practical recommendations for maxTotal, maxIdle, minIdle, idle monitoring, and warm‑up to ensure stable and efficient Redis operations in Java applications.
This guide explains why a Redis cluster is needed for large data sets, describes the hash‑slot architecture introduced in Redis 3.0, and provides step‑by‑step instructions—including directory creation, configuration changes, instance startup, Ruby gem installation, and cluster creation commands—to build a functional Redis cluster on a Mac.
Through kernel‑level analysis we discovered that Redis packet loss stemmed from rx_dropped buffer exhaustion caused by interrupt‑handling backlogs, and resolved it by assigning NIC interrupts to specific cores on one NUMA node while binding Redis processes to the other, eliminating loss under dual‑10 GbE load.
This article explains common Redis caching problems—including cache avalanche, cache penetration, cache warmup, cache update, and cache downgrade—and offers practical, entry‑level solutions such as distributed locking, random expiration, bloom filters, pre‑loading strategies, and graceful degradation to keep systems stable under load.
This article explains what Redis is, outlines its common data structures and persistence options, and delves into why Redis achieves exceptionally high performance through in‑memory storage, a single‑threaded event loop, multiplexed I/O, and simple data models, providing interview‑ready insights.
This article explains how to avoid data races in high‑traffic distributed systems by comparing pessimistic and optimistic concurrency control, demonstrating RDBMS row locks and a Redis‑based distributed lock implementation with Python code examples.
This guide introduces Redis as an advanced key‑value store, explains how to start the server and use its CLI tools, and provides detailed command references and demos for strings, lists, sets, sorted sets, hashes, transactions, replication, and pub/sub.
This article details a two‑stage approach for creating a geo‑distributed active‑active infrastructure for large‑scale games, covering a pseudo active‑active design with private lines and smart DNS, followed by a true active‑active solution using Redis Sentinel and MySQL clustering with performance comparisons.
This article explains the challenges of high‑concurrency flash‑sale systems, analyzes the overselling problem caused by simultaneous database updates, and presents four optimization strategies—including unsigned fields, MySQL transactions, file locks, and Redis queues—accompanied by complete PHP code examples and test data.
This comprehensive guide introduces Redis fundamentals, covering its core data structures and essential commands, then delves into performance optimization, high‑availability setups with replication and Sentinel, and scaling strategies using Redis Cluster, providing practical examples and best‑practice recommendations for robust in‑memory data management.
Redis and Memcached are compared across network I/O models, supported data structures, memory management, persistence, consistency, and clustering, revealing Redis’s richer feature set and flexibility while highlighting Memcached’s simplicity and speed, helping developers choose the right in‑memory solution for their workloads.
This article introduces Celery, a flexible Python distributed task queue, explains its architecture—including broker, beat, worker, and result backend—then provides a complete, step‑by‑step setup using RabbitMQ and Redis, covering installation, configuration, task definition, worker launch, custom exchanges, and queue routing.
This article explains why distributed locks are needed in Java applications, outlines the essential conditions they must satisfy, and compares three practical implementations—database‑based, Redis‑based, and Zookeeper‑based—providing code snippets and performance considerations for each.
This article explains how to correctly implement a Redis-based distributed lock in Java, covering essential reliability requirements, step‑by‑step code for acquiring and releasing locks, and detailed analyses of common flawed approaches, ensuring atomicity and proper ownership handling.
Envoy’s extensible filters enable detailed access logging and database sniffing for MongoDB, DynamoDB, and Redis, offering customizable log formats, per‑operation statistics, health checks, and future enhancements such as circuit breaking and retries, while providing configuration guidance for each filter.
The article details iQIYI’s Bubble social service cache architecture, comparing Couchbase and Redis, explaining vBucket design and management UI, and presenting three real‑world optimizations—like‑system key redesign, voting‑system aggregation, and SDK upgrade—along with migration, synchronization, and operational best‑practice recommendations.
This article introduces RDR, an open-source visualization platform developed by Xueqiu's SRE team to safely and efficiently analyze Redis memory consumption by parsing RDB files, estimating key-level memory usage based on internal data structures, and generating intuitive statistical reports for operational optimization.
This article explains how to replace traditional in‑process locks with a Redis‑backed distributed lock service, detailing the overall architecture, server and client designs, management features, lock lifecycle, grading strategies, and fallback options such as database and Zookeeper solutions.
This guide explains Redis’s core features, shows how to design clear key naming conventions, and demonstrates practical applications of the string, hash, list, set, and sorted‑set data types with concrete commands and examples for building fast, memory‑based caches.
This article explains the design and implementation of a space‑efficient Bloom filter using Redis bit operations, covering theory, false‑positive calculations, PHP code, performance testing on billions of daily logs, and optimizations such as pipelining and sharding for large‑scale deduplication.
This article explains the necessity of globally unique and trend‑ordered identifiers for business systems, compares database auto‑increment, UUID, Redis, Snowflake, and MongoDB ObjectId solutions, and outlines their advantages, drawbacks, and best‑practice design criteria.
This article explains Ctrip's design of a globally unique, high‑concurrency user ID generator for sharded MySQL databases, reviews common industry solutions, and details the final optimized approach that combines a MySQL auto‑increment table with in‑memory segment allocation to achieve millisecond‑level response times.
This guide explains Redis's core characteristics, practical key‑naming conventions, and detailed application scenarios for each data type—including strings, hashes, lists, sets, and sorted sets—complete with code examples and performance tips.
This article details the evolution of Qunar's TTS pricing engine from a monolithic V1 implementation with dual-level caching and blocking HTTP interfaces to a scalable V2 architecture featuring service separation, asynchronous processing, CQRS-based rule storage, canal synchronization, Solr and Redis indexing, and Kafka-driven data pipelines.
This article explains why rate limiting is essential for high‑traffic services, describes the token‑bucket algorithm, shows how to use Guava's RateLimiter and Cache for single‑node limits, and presents a Redis‑based solution that works across distributed instances.
This article outlines the shortcomings of using crontab for large‑scale job execution, defines the requirements for a custom distributed scheduler, describes its three‑component architecture (trigger, monitor, management), and details key technical solutions such as process isolation, distributed locking, and log aggregation.
This article describes Ctrip's design of a distributed, globally unique user ID generator for MySQL migration, covering requirements, evaluation of common approaches such as auto‑increment, UUID, Snowflake and Redis, and detailing the final Flicker‑based solution with segment caching using AtomicLong to achieve high concurrency and reliability.
This article shares practical experiences and step‑by‑step guidance on tuning Redis server settings, choosing appropriate eviction policies, limiting client output buffers, disabling risky commands, handling Sentinel‑based master‑slave failover, and selecting the right persistence strategy for reliable and high‑performance deployments.
This article explains how to build reliable distributed locks with Redis, covering essential commands, common pitfalls, improvements using GETSET, Lua scripting for atomicity, and complete Java code examples that address deadlock and unlock vulnerabilities.
This article summarizes key insights from the Redis track at the Cloud Xi Conference, covering Alibaba Cloud ApsaraCache's unique features, Redis Enterprise's market dominance and modules, Codis's evolution and asynchronous migration techniques, and Redisson's advanced Java client capabilities for distributed caching and locking.
An in‑depth comparison of Memcached and Redis reveals how both key‑value cache servers operate, covering their service models, event loops, memory allocation strategies, database implementations, persistence mechanisms, transaction support, and publish/subscribe features, highlighting the trade‑offs between simplicity and rich functionality.
Redis is an open-source, in-memory data store offering versatile structures and commands; this guide explains its fundamentals, key data types, essential commands, practical examples, performance optimization techniques, replication, clustering, and Java client choices to help you design robust, high-performance Redis solutions.
This guide walks you through preparing a Linux host, installing JDK, Maven, MySQL, downloading CacheCloud, configuring its database and properties, building the project, deploying the web service, and using the UI to add machines and create or import Redis clusters.
This article examines the technical challenges of handling 50,000 requests per second in flash‑sale systems, covering request interface design, high‑concurrency bottlenecks, overload protection, anti‑cheat mechanisms, and data‑safety techniques such as Redis caching, pessimistic and optimistic locking.
This article compares Redis and Memcached across data‑type support, memory management, persistence mechanisms, and clustering features, highlighting their architectural differences, performance trade‑offs, and suitable use‑cases to help developers choose the right in‑memory storage solution.
This article examines the technical challenges of handling massive concurrent requests during flash‑sale and ticket‑buying events, offering practical backend design, performance tuning, anti‑cheat measures, and data‑safety techniques to keep web systems stable under extreme load.
On September 23 2017, the CRUG Redis Technology Salon in Shenzhen, hosted by vivo, gathered about one hundred developers and five experts from Tencent, Sina and Vivo to share practical Redis experiences, discuss its memory‑store advantages, enjoy prizes, live Q&A, and receive a downloadable PPT via the official WeChat account.
This article provides a comprehensive guide to Redis, covering installation steps, core data structures such as strings, hashes, lists, sets and sorted sets, and advanced capabilities like pub/sub, transactions, pipelining, and persistence, plus practical client examples and a summary of its performance advantages.
This article explains Redis's five core data structures, their internal representations, practical use‑cases, memory‑saving configuration parameters, and the four persistence mechanisms, providing concrete examples and recommendations to improve performance and stability.
This article presents a comprehensive Java backend engineer learning roadmap, outlining essential skills from version control and Maven to core Java, frameworks, system and JVM performance tuning, messaging middleware, OAuth, Redis, and data processing, accompanied by recommended books and online resources for each topic.
This article details the architecture and evolution of a headline recommendation system, covering data aggregation, storage strategies using MySQL and Redis, challenges with reload latency and memory usage, and the optimizations—including data separation, Redis migration, and query pipeline improvements—that enabled scalable, efficient backend operations.
The article describes the design, storage, update mechanisms, and optimization strategies of a headline recommendation platform that aggregates various data types using algorithms, MySQL, Redis, and a modular data‑fetching framework to achieve scalable and efficient content delivery.
This article recounts Xiaomi's rapid development of a high‑concurrency flash‑sale platform for the 2014 "Mi Fan Festival", detailing the design choices, trade‑offs, and performance optimizations that enabled millions of users to purchase phones simultaneously.
By serializing user feature data with Java's Protostuff (built on Protobuf) and then applying JDK Gzip compression before storing it in Redis, the author shrank typical 70 KB per‑user payloads to under 10 KB, enabling billions of records with cross‑language compatibility and no schema‑breakage.
This article examines the client‑server architecture of Memcached, the slab‑based memory management of both Memcached and Redis, compares their performance, memory efficiency, persistence, data structures and networking models, and presents practical Redis use cases such as caching, ranking, pub/sub, queues, and real‑time analytics.
This article explains why caching is essential for backend services, outlines common cache problems such as penetration, concurrency, and avalanche, and compares cache-aside, read/write‑through, and write‑back patterns with practical guidance on choosing and updating caches.
This article explains how a web system can evolve from handling 100,000 daily visits to over 100 million by progressively implementing multi‑level caching, various load‑balancing techniques—including HTTP redirects, reverse‑proxy, IP‑level, DNS, and GSLB—and optimizing MySQL through indexing, connection pooling, sharding, replication, and integrating memory caches such as Redis to ensure high performance and reliability.
This article explains how to protect Redis deployments from single‑point failures by using master‑slave replication, manual failover procedures, and the automated high‑availability Sentinel solution, providing practical guidance for reliable disaster recovery in non‑clustered environments.
This article describes the business flow, storage schema, template‑method based code framework, workflow integration, Redis‑based lock mechanism, and two major refactoring iterations that improve the permission‑application approval process for the Do platform.
This article examines why Redis data can disappear, walks through a real incident where 90,000 keys vanished, and provides concrete monitoring, diagnostic, and preventive measures to avoid cache‑only and storage‑critical data loss scenarios.
This article examines the evolution of distributed locking—from simple MySQL table locks to Redis cache locks and the Redlock algorithm—highlighting their limitations, expert criticisms, and why Zookeeper often provides a more reliable solution for high‑availability systems.
This article walks through building a Spring Boot application that protects HTTP endpoints using OAuth2, covering password and client‑credentials flows, Maven setup, resource and authorization server configuration, in‑memory users, token retrieval, and accessing secured resources with detailed code examples.
This article walks through creating a video‑aggregation platform for Hearthstone streamers by scraping data from sites like Douyu, processing it with Python regular expressions, storing results in Redis or LeanCloud, and exposing the rankings via a Django‑based web front‑end with periodic cloud‑function refreshes.
This article outlines comprehensive MySQL best practices, covering development and operational standards, high‑availability architecture choices such as Keepalived, MHA and Percona XtraDB Cluster, sharding strategies (vertical and horizontal), and how Redis can be leveraged to offload read pressure.
Juice is an open‑source Mesos‑based distributed task scheduling framework that abstracts Docker tasks, provides REST APIs, leverages Redis queues, and implements custom resource allocation, offering high resource utilization and fault‑tolerant execution for audio‑video processing workloads.
The team rescued a crashing Redis cache handling 100K‑120K QPS by shrinking Nginx Lua timeouts, trimming connection pools, adding four Redis nodes behind Twemproxy, and splitting keys to raise cardinality, which eliminated connection spikes, balanced shard load, and restored stable performance.
This comprehensive guide introduces Redis fundamentals, explores its rich data structures and essential commands, delves into performance optimization techniques, explains replication and clustering strategies, and compares popular Java clients, providing practical examples and best‑practice recommendations for reliable, high‑performance deployments.
Vipshop faced massive data growth that broke traditional RDBMS, causing slow OLAP queries, inefficient ETL, and long development cycles, so it iteratively rebuilt its analytics stack—adding Hadoop/Hive, a self‑service UI, Presto, Kylin, and Redis—to achieve sub‑second query responses, higher concurrency, and a flexible, low‑latency BI solution.
This article outlines a comprehensive Redis multi‑datacenter deployment plan, detailing master‑backup placement, tree‑structured master‑slave topology across three sites, configuration checks, Pull&Push synchronization mechanics, and includes concrete code snippets illustrating connection, RDB generation, and incremental replication processes.
An order system retrieved incorrect product size data due to master‑slave database lag causing stale Redis cache, and the article explains the original flawed flow, the revised solution that writes to cache during sync, and best practices for cache updates, read‑through, and QA testing.
This article explains Redis Cluster’s distributed architecture, the 16,384 hash slot mechanism, node addition and removal, decentralised request routing, fault‑tolerance through master‑slave replication, slot migration without service interruption, and the internal data structures that enable these features.
This article details Ctrip’s redesign of its real‑time user behavior service, covering the new architecture, data flow, use of Java, Kafka, Storm, Redis, and MySQL, and how it achieves high real‑time performance, availability, scalability, and fault‑tolerance to support massive travel‑industry traffic.
This article explains the evolution of real-time message delivery—from short polling to long polling, streaming, and WebSocket—introduces Socket.io, and details a multi‑node cluster architecture using Redis, Nginx, and Node.js for scalable chat applications.
This article explores three progressive implementations for a complex e‑commerce search interface, comparing a monolithic SQL solution, an optimized multi‑query approach, and a Redis‑based caching strategy that leverages sets and sorted sets for fast, scalable results.
This article explains how Redis-ML enables real‑time machine learning by extending Redis with modules, covering its architecture, random‑forest inference, performance benchmarks against Spark, and a complete movie‑recommendation use case with Docker, Scala, and Python examples.
This article explains how to protect API servers from abuse by implementing rate limiting using the Token Bucket algorithm, discusses its drawbacks, and provides practical Java and Redis-based solutions with code examples and performance considerations.
This article explains how to design concise Redis keys that enable multi‑condition and fuzzy queries by using a structured naming convention, demonstrates the implementation within a Java SSM project, and provides code snippets for key assembly, querying, and deletion.
This article explains why Redis high‑availability is essential, details the inner workings of Redis Sentinel, compares several HA architectures—including Sentinel with DNS or VIP, client‑side Sentinel, Keepalived/Haproxy, Redis Cluster, Twemproxy, and Codis—lists their pros and cons, and shares practical best‑practice recommendations for building reliable Redis deployments.
This article explains Redis fundamentals, details the Sentinel mechanism, compares several high‑availability deployment patterns—including Sentinel with DNS or VIP, client‑direct connections, Keepalived/Haproxy, Redis Cluster, Twemproxy, and Codis—provides their advantages and drawbacks, and offers practical best‑practice recommendations for reliable production use.
This article explains the internal structure and encoding of Redis's ziplist (compressed list), describes its memory layout and node format, and analyzes how Redis leverages this data structure across different types such as lists, hashes, and sorted sets to reduce memory usage and fragmentation.
This article presents a comprehensive redesign of Baidu Waimai’s client‑side activity module, detailing background challenges, design goals, functional and performance specifications, trade‑off analyses of three architectural alternatives, and the chosen parallel HTTP‑request solution with monitoring, degradation, and phased rollout plans.
This article provides a detailed walkthrough of Pika’s write2file binlog mechanism, covering manifest and binlog file structures, record formats, core implementation classes, and step‑by‑step procedures for constructing, updating, producing, and consuming logs in a large‑capacity Redis‑compatible storage system.
This article chronicles the multi‑year architectural evolution of Tongcheng Travel's push notification platform, detailing early batch‑job designs, successive redesigns using Redis, MongoDB, Kafka, Go, and .NET, and the performance, scalability, and operational improvements achieved through each major version.
This article explains the meaning of Big O notation—O(n), O(1) and O(log n)—using intuitive box-and‑card analogies, shows how Redis command complexities are expressed, and highlights why constant‑time operations are the most efficient for large data sets.
This article explains why rate limiting is essential for service performance and data security, and demonstrates two practical Redis-based implementations—a Lua script approach and a Redis‑cell module method—complete with code examples, usage details, and a brief comparison.
This step‑by‑step guide shows how to set up two Tomcat instances, configure Nginx as a reverse‑proxy load balancer, and use Redis to share session data, solving session‑loss issues in a simple load‑balanced environment.
Pika, developed by 360’s Web Platform and DBA teams, is a Redis‑compatible, disk‑based key‑value store that addresses Redis’s high memory cost and scalability limits by offering persistent storage, multi‑threading, compression, and easy migration tools, making large‑capacity data handling cheaper and more reliable for enterprises.
This guide walks through setting up a distributed log collection and analysis platform using ELK (Elasticsearch, Logstash, Kibana) together with Redis on two CentOS machines, covering environment preparation, component installation, configuration, testing, and visualizing nginx access logs.
This article describes the background, architecture, encountered performance bottlenecks, and a three‑level caching strategy (Redis‑based) implemented in Python to accelerate a measurement platform that aggregates bug, issue, and code metrics for a rapidly growing development team.
This guide demonstrates how to configure a highly available Redis deployment using master‑slave replication, Redis Sentinel for automatic failover, and virtual IP (VIP) migration, covering environment setup, configuration files, firewall adjustments, testing procedures, and client connection strategies.
This article examines common performance and reliability problems encountered in Redis master‑slave deployments—such as AOF and SAVE settings, key count mismatches, client output buffer limits, replication backlog size, and node liveness checks—and provides concrete configuration commands and tuning strategies to improve stability, especially in cloud environments.
The article describes how Ctrip rebuilt its real‑time user behavior platform using a Java‑based stack (Kafka, Storm, Redis, MySQL) to achieve millisecond‑level latency, high availability, scalable performance, and robust handling of traffic spikes, failures, and data back‑pressure.
This article describes the challenges and solutions behind designing a high‑availability, low‑latency ranking service that supports tens of thousands of leaderboards, optimizes storage engine choices, automates scheduling, and isolates resources using ZooKeeper, Redis, and container‑based deployments across multiple data centers.
This article examines 360’s explosive KV storage demand and compares three solutions—Redis, Redis Cluster, and Pika—detailing their features, performance, persistence options, eviction policies, architectures, migration tools, and ideal usage scenarios for high‑traffic, large‑scale applications.
This article provides a comprehensive technical comparison between Redis and Memcached, covering server‑side operations, memory efficiency, performance characteristics, supported data types, memory management mechanisms, persistence options, and clustering architectures, illustrated with diagrams and concrete command examples.
This article recounts a Redis server hijacking incident, details the step‑by‑step investigation and remediation process, and offers practical security recommendations to protect Redis deployments on Linux environments.
This article explains how to deploy a Redis master‑slave cluster with Sentinel for high availability, details application configuration, highlights a subtle issue where Redis passwords are automatically rewritten after failover, and provides three remediation approaches including a source‑code patch with GitHub links.
This article explores the challenges of mutual exclusion and idempotency in distributed environments, explains the underlying principles of locks in multi‑threaded and multi‑process contexts, and presents practical implementations using Zookeeper, Redis, Tair, and the Cerberus and GTIS frameworks to ensure reliable, scalable operations.
This article explains why availability and reliability are essential for web APIs, outlines four common rate‑limiting approaches used by Stripe—including request, concurrent, usage‑based, and worker‑utilization limiters—and provides practical guidance on implementing token‑bucket limiters with Redis while ensuring safe error handling and gradual rollout.
This article explains how to modify Redis 3.0.7 by adding LOADAOF and LOADRDB commands that enable online loading of AOF and RDB files, eliminating the need to restart the server even in master‑slave replication scenarios.
The article surveys cache fundamentals—request flow, hit rates, eviction policies, and media—then compares local versus distributed caches and reviews concrete implementations such as programmatic caches, Ehcache, Guava, memcached, and Redis, before detailing Spring’s annotation‑driven caching and a Meituan case study on custom annotation caches.
This article explains how attackers can combine SSRF vulnerabilities with unauthorized Redis access and unsafe serialization in Celery to infiltrate internal networks, illustrating the attack flow, exploitation techniques, and mitigation considerations for operations and security teams.
This article explains why Redis data must be persisted, compares the two built‑in methods—RDB snapshotting and Append‑Only File (AOF)—and provides practical configuration tips, command usage, performance considerations, and verification tools for reliable backup and recovery.
This article explains why a legacy Rails 3 application switched from CouchDB to Redis for caching a heavy daily‑updated report, detailing the design, configuration files, service class, producer and consumer code, and the resulting performance improvements.
The article shows how attackers automate mass exploitation of widely‑known flaws—scanning the Internet for open MongoDB, Redis, ElasticSearch or Struts2 services, using unauthenticated access or public PoCs to encrypt data, execute code, or build botnets, and stresses that timely patching and secure defaults are essential to stop such N‑day attacks.
An in‑depth review of the heated debate between Redis creator antirez and distributed‑systems expert Martin Kleppmann over the safety of Redis’s Redlock algorithm, covering single‑node lock pitfalls, failover issues, timing assumptions, fencing tokens, and practical recommendations for when to use Redlock versus simpler locks.
This article introduces Redis's five core data structures—String, List, Set, Hash, and Sorted Set—detailing their characteristics, common commands, additional operations, and typical use cases, providing a comprehensive guide for developers working with Redis.
