Tagged articles
BigKey
25 articles · Page 1 of 1
This article walks through production‑grade Redis object‑storage design, comparing String and Hash data structures, explaining why large keys and hot keys can cripple performance, and presenting a decision tree, split strategies, thread‑model insights, code samples, and monitoring recommendations to build a scalable, observable cache layer.
BigKeyCacheDesignHash
0 likes · 34 min read

The article explains what constitutes a Redis big key, outlines its performance and stability hazards—including bandwidth consumption, request timeouts, memory overflow, and cluster disruption—and presents practical commands and incremental deletion techniques to locate and safely remove such keys.
AsyncDeleteBigKeyCluster
0 likes · 4 min read

This article walks through the motivation, design, implementation, performance tuning, deployment, and lessons learned when creating a Golang‑based offline Redis RDB parser that efficiently identifies large keys without impacting a live cluster.
BigKeyRDBRedis
0 likes · 12 min read

During a major promotion a huge activity generated an oversized Redis cache key that caused cache‑penetration, saturated network bandwidth, and triggered a cascade of service failures, prompting a detailed root‑cause analysis and a set of mitigation and prevention measures.
BackendBigKeyCache
0 likes · 7 min read

A promotional event created an oversized Redis cache entry that, combined with cache‑penetration bursts, saturated network bandwidth and caused a service outage, prompting mitigation through Protostuff serialization, gzip compression, request throttling, and enhanced monitoring, while recommending design‑time cache planning and stress testing to prevent future big‑key failures.
BackendBigKeyCache
0 likes · 9 min read

This article presents a lightweight, zero‑code‑change solution that leverages eBPF uprobe tracing to monitor Redis in real time, capture client IP, command arguments, and response size, detect big‑key operations, and report them with minimal performance impact.
BigKeyeBPFperformance
0 likes · 18 min read

The article explains how to detect and troubleshoot Redis latency spikes by measuring baseline performance, using slowlog and latency‑monitor, checking network RTT, fork‑induced pauses, huge pages, swap usage, AOF settings, expiration handling, and big‑key problems, providing concrete commands and mitigation steps.
AOFBigKeyPipeline
0 likes · 19 min read

This article explains how to determine whether Redis is truly experiencing latency spikes, outlines a step‑by‑step benchmarking process, identifies common causes such as high‑complexity commands, big keys, memory limits, fork overhead, AOF settings, CPU binding, swap usage, and provides concrete configuration and code examples to resolve each issue.
AOFBigKeyPerformance Tuning
0 likes · 39 min read

The article explains what constitutes a big key in Redis, why they arise, the performance and blocking issues they cause, and provides multiple practical methods—including built‑in commands, SCAN, MEMORY USAGE, RDB analysis tools, and cloud services—to detect and mitigate big keys effectively.
BigKeyOptimizationRedis
0 likes · 10 min read

This article explains why oversized Redis keys (BigKeys) cause data skew, network blockage, slow queries, and high CPU load, shows how to detect them with redis-cli and other tools, and provides practical strategies—including lazy deletion, key splitting, and preventive design—to mitigate their impact on production systems.
BigKeyLazy FreeRedis
0 likes · 22 min read

This article explains what constitutes a Redis BigKey, why oversized keys degrade performance through data skew, network blocking, slow queries and CPU pressure, and provides practical detection methods, open‑source tooling, and mitigation techniques such as lazy‑free deletion, incremental scans, and key sharding.
BigKeyDELETEOptimization
0 likes · 21 min read

BigKey and HotKey issues in Redis clusters arise when oversized keys block processing or a single key receives excessive requests, causing timeouts, memory overflow, shard collapse, and performance degradation, but can be detected during testing using Redis commands, visual clients, and open‑source analysis tools.
BigKeyCacheHotKey
0 likes · 8 min read


政采云技术Aug 15, 2023 · Databases
This article explains what Redis bigkeys are, their impact on performance and memory, how they are generated, methods to detect and analyze them—including built‑in commands, SCAN, memory usage, and RDB file inspection—and practical steps to mitigate their effects.
BigKeyRDB analysisRedis
0 likes · 12 min read

This guide explains how to identify and resolve Redis performance degradation by measuring baseline latency, checking slowlog, avoiding high‑complexity commands, handling big keys, managing expiration spikes, tuning memory limits, reducing fork overhead, disabling huge pages, configuring AOF, binding CPUs, preventing swap usage, fixing memory fragmentation, and using lazy‑free mechanisms.
AOFBigKeyMemory
0 likes · 35 min read

This guide outlines Alibaba Cloud Redis development standards, covering key naming conventions, value design, command usage, client configuration, eviction policies, and tools for data synchronization, big-key management, and monitoring, helping developers avoid common pitfalls and optimize performance.
BigKeyClientPoolingCommandUsage
0 likes · 12 min read

The article examines a real‑world incident where an unsafe Redis command caused a $4 million loss, then demonstrates performance testing with ten million keys, shows how to disable dangerous commands, replace KEYS with SCAN, and avoid big‑key issues for safer database operations.
BigKeyDatabase SecurityRedis
0 likes · 6 min read

BigKey and HotKey are common Redis cluster problems that can degrade performance, cause timeouts, network congestion, and even system-wide failures; this article explains their definitions, impacts, detection methods, and practical mitigation strategies—including key splitting, local caching, and migration optimizations—based on real-world production cases.
BigKeyHotKeydatabase
0 likes · 22 min read

The article explains what Redis bigkeys are, why they arise, the performance and availability problems they cause, and presents practical detection methods and optimization techniques—including key splitting, tool improvements, and migration safeguards—to help DBAs and developers prevent and resolve bigkey‑related incidents.
BigKeyRedisdatabase
0 likes · 14 min read

Bigkeys—Redis values over 1 MB or structures with more than 2,000 elements—cause memory imbalance, command blocking, network overload, and migration failures, so DBAs must detect them using built‑in commands or RDB analysis, split or partition oversized keys, and tune migration settings to preserve performance and availability.
BigKeyRedisScaling
0 likes · 14 min read

This article walks through a real‑world incident where a Redis cache big‑key caused service timeouts, explains how to identify the problem using cluster metrics, outlines detection tools and commands, and provides practical steps to delete big keys and prevent future occurrences.
BigKeyCacheRedis
0 likes · 8 min read

This guide outlines Redis's fundamental limitations, common performance issues such as big keys, slow queries, and connection‑pool exhaustion, and provides practical recommendations on architecture, configuration, and operational diagnostics to help developers avoid hitting Redis's boundaries.
Best PracticesBigKeyCache
0 likes · 19 min read

This article explains the typical reasons behind Redis latency spikes—such as complex commands, big keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network overload—and provides practical steps and monitoring techniques to identify and resolve each problem.
BigKeyPerformance TuningRedis
0 likes · 18 min read

This article examines the typical reasons Redis latency spikes—such as high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation—and provides practical diagnostics and mitigation steps to keep Redis responsive.
BigKeyRedislatency
0 likes · 17 min read

This article explains why using DEL on massive Redis keys can cause long‑lasting blocks or crashes, and presents incremental scan‑based deletion and the UNLINK command as reliable, non‑blocking alternatives for Hashes, Lists, Sets, and Sorted Sets.
BigKeyPerformance OptimizationUNLINK
0 likes · 6 min read

This article presents comprehensive Alibaba Cloud Redis development standards covering key and value design, lifecycle management, command usage, client integration, tooling, and efficient big‑key deletion techniques to help developers avoid common pitfalls and improve performance.
BigKeyCommand OptimizationJava
0 likes · 10 min read
