Skip to main content
Mapagam

43 SECTIONS · 533 TOPICS

Redis Roadmap

  1. Installing and Configuring Redis

    1. 1. Installing Redis Server
    2. 2. Starting Redis Server
    3. 3. Connecting with Redis CLI
    4. 4. Configuring redis.conf File
    5. 5. Setting Configuration at Runtime
    6. Example: Live config changes via CONFIG SET
    7. 6. Getting Configuration Values
    8. Example: Inspect runtime configuration
    9. 7. Persisting Runtime Configuration
    10. 8. Setting Server Verbosity
    11. 9. Configuring Database Count
    12. 10. Understanding Redis Data Model

  2. Managing Databases

    1. 1. Selecting Database
    2. 2. Getting Database Size
    3. 3. Flushing Single Database
    4. 4. Flushing All Databases
    5. 5. Moving Keys Between Databases
    6. 6. Swapping Databases
    7. Example: Zero-downtime data refresh
    8. 7. Using Async Flushing
    9. 8. Configuring Database Count

  3. Managing Keys and Expiration

    1. 1. Checking Key Existence
    2. 2. Deleting Keys
    3. 3. Getting Key Type
    4. 4. Renaming Keys
    5. 5. Setting Key Expiration
    6. 6. Setting Millisecond Expiration
    7. 7. Removing Expiration
    8. 8. Getting Time to Live
    9. 9. Finding Keys by Pattern
    10. Example: Safe pattern scan
    11. 10. Getting Random Key
    12. 11. Copying Keys
    13. 12. Touching Keys
    14. 13. Dumping and Restoring Keys

  4. Working with Object Inspection

    1. 1. Getting Object Encoding
    2. 2. Getting Object Frequency
    3. 3. Getting Object Idle Time
    4. 4. Getting Object Reference Count
    5. 5. Getting Object Help
    6. 6. Understanding Internal Encodings
    7. 7. Understanding List Encodings
    8. 8. Understanding Hash Encodings
    9. 9. Understanding Set Encodings
    10. 10. Understanding Sorted Set Encodings

  5. Working with String Values

    1. 1. Setting String Values
    2. Example: Atomic SET with TTL and condition
    3. 2. Getting String Values
    4. 3. Setting Multiple Values
    5. 4. Setting with Expiration
    6. 5. Setting if Not Exists
    7. 6. Getting and Setting
    8. 7. Appending to Strings
    9. 8. Getting String Length
    10. 9. Getting Substring
    11. 10. Incrementing Numbers
    12. Example: Atomic counter
    13. 11. Decrementing Numbers
    14. 12. Incrementing Floats

  6. Working with Lists

    1. 1. Pushing Elements
    2. 2. Pushing if Exists
    3. 3. Popping Elements
    4. 4. Getting List Length
    5. 5. Getting Elements by Range
    6. 6. Getting Elements by Index
    7. 7. Setting Elements by Index
    8. 8. Inserting Elements
    9. 9. Trimming Lists
    10. 10. Removing Elements
    11. 11. Getting List Position
    12. 12. Using LMOVE for Element Transfer
    13. Example: Reliable worker queue
    14. 13. Using LMPOP for Multiple Pops

  7. Working with Sets

    1. 1. Adding Set Members
    2. 2. Removing Set Members
    3. 3. Checking Member Existence
    4. 4. Getting All Members
    5. 5. Getting Set Cardinality
    6. 6. Getting Random Members
    7. 7. Popping Random Members
    8. 8. Moving Members Between Sets
    9. 9. Computing Set Union
    10. 10. Computing Set Intersection
    11. 11. Computing Set Difference
    12. 12. Scanning Set Members

  8. Working with Sorted Sets

    1. 1. Adding Sorted Set Members
    2. Example: Leaderboard update
    3. 2. Removing Members
    4. 3. Getting Members by Rank
    5. 4. Getting Members by Score
    6. 5. Getting Member Score
    7. 6. Getting Member Rank
    8. 7. Getting Set Cardinality
    9. 8. Counting by Score Range
    10. 9. Incrementing Member Score
    11. 10. Removing by Rank
    12. 11. Removing by Score
    13. 12. Popping Min and Max Members
    14. 13. Computing Sorted Set Union
    15. 14. Computing Sorted Set Intersection
    16. 15. Scanning Sorted Set

  9. Working with Hashes

    1. 1. Setting Hash Fields
    2. 2. Getting Hash Fields
    3. 3. Getting All Fields
    4. 4. Checking Field Existence
    5. 5. Deleting Hash Fields
    6. 6. Getting Field Count
    7. 7. Setting if Field Not Exists
    8. 8. Incrementing Hash Values
    9. 9. Getting String Length of Field
    10. 10. Getting Random Fields
    11. 11. Scanning Hash Fields
    12. 12. Setting Field Expiration
    13. Example: Per-field expiration on session hash

  10. Working with Bitmaps

    1. 1. Setting Bit Values
    2. 2. Getting Bit Values
    3. 3. Counting Set Bits
    4. 4. Finding First Bit
    5. 5. Performing Bitwise Operations
    6. Example: Daily active users intersection
    7. 6. Getting Bit Field Values
    8. 7. Setting Multiple Bit Fields
    9. 8. Using BITFIELD_RO for Read-Only Operations
    10. 9. Understanding Bitmap Memory Efficiency
    11. 10. Using Bitmaps for Analytics
    12. 11. Implementing Bitmap-Based Counters
    13. Example: Packed per-user counters with BITFIELD

  11. Working with HyperLogLogs

    1. 1. Adding Elements
    2. 2. Counting Unique Elements
    3. 3. Merging HyperLogLogs
    4. Example: Monthly unique visitors
    5. 4. Understanding Cardinality Estimation
    6. 5. Handling Memory Efficiency
    7. 6. Using for Unique Visitor Tracking
    8. 7. Understanding Error Rate
    9. 8. Comparing with Set-Based Counting
    10. HyperLogLog
    11. SET

  12. Working with Geospatial Indexes

    1. 1. Adding Geospatial Data
    2. 2. Getting Member Position
    3. 3. Calculating Distance
    4. 4. Getting Geohash
    5. 5. Searching by Radius
    6. 6. Searching by Area
    7. Example: Nearest 10 shops within 5km
    8. 7. Storing Search Results
    9. 8. Removing Geospatial Members
    10. 9. Understanding Geospatial Precision
    11. 10. Using Distance Units

  13. Working with Streams

    1. 1. Adding Stream Entries
    2. 2. Reading Stream Entries
    3. 3. Getting Stream Length
    4. 4. Trimming Streams
    5. 5. Deleting Stream Entries
    6. 6. Creating Consumer Groups
    7. 7. Reading as Consumer
    8. 8. Acknowledging Messages
    9. 9. Getting Pending Messages
    10. 10. Claiming Pending Messages
    11. 11. Getting Stream Info
    12. 12. Managing Consumers
    13. 13. Setting Stream ID

  14. Implementing Search Patterns

    1. 1. Using Pattern Matching
    2. 2. Implementing Cursor-Based Iteration
    3. Example: SCAN loop in bash
    4. 3. Scanning Hash Fields
    5. 4. Scanning Set Members
    6. 5. Scanning Sorted Set Members
    7. 6. Setting Scan Count
    8. 7. Using Pattern Filters
    9. 8. Using TYPE Filter with SCAN
    10. 9. Using NOVALUES Option
    11. 10. Handling Large Keyspaces
    12. 11. Implementing Efficient Pagination
    13. Example: Score-based pagination on sorted set
    14. 12. Avoiding KEYS in Production

  15. Implementing Blocking Commands

    1. 1. Using Blocking List Operations
    2. 2. Using BLMOVE for Reliable Queues
    3. 3. Using BLMPOP for Multiple List Operations
    4. 4. Using Blocking Sorted Set Operations
    5. 5. Using BZMPOP for Multiple Sorted Sets
    6. 6. Using Blocking Stream Reads
    7. 7. Setting Block Timeout
    8. 8. Blocking Multiple Keys
    9. 9. Understanding Client Blocking
    10. 10. Handling Timeout Responses
    11. 11. Implementing Queue Patterns
    12. Example: Reliable worker loop
    13. 12. Avoiding Indefinite Blocking

  16. Managing Transactions

    1. 1. Starting Transactions
    2. 2. Executing Transactions
    3. Example: Atomic two-key update
    4. 3. Discarding Transactions
    5. 4. Watching Keys
    6. 5. Unwatching Keys
    7. 6. Understanding Atomicity Guarantees
    8. 7. Implementing Optimistic Locking
    9. Example: Safe counter update with WATCH
    10. 8. Combining with WATCH for Check-and-Set
    11. 9. Handling Transaction Errors
    12. 10. Understanding No Rollback Behavior

  17. Using Lua Scripting

    1. 1. Executing Scripts
    2. 2. Caching Scripts
    3. 3. Passing Keys and Arguments
    4. 4. Using Redis Commands in Scripts
    5. Example: Atomic compare-and-set
    6. 5. Returning Values from Scripts
    7. 6. Understanding Script Atomicity
    8. 7. Checking Script Existence
    9. 8. Flushing Script Cache
    10. 9. Killing Running Scripts
    11. 10. Debugging Scripts
    12. 11. Handling Script Errors
    13. 12. Implementing Atomic Operations
    14. Example: Atomic rate-limit increment with TTL

  18. Working with Redis Functions

    1. 1. Creating Functions
    2. 2. Calling Functions
    3. 3. Listing Functions
    4. 4. Deleting Functions
    5. 5. Dumping Functions
    6. 6. Restoring Functions
    7. 7. Flushing Functions
    8. 8. Getting Function Stats
    9. 9. Killing Running Functions
    10. 10. Understanding Functions vs Lua Scripts

  19. Implementing Pub/Sub Messaging

    1. 1. Publishing Messages
    2. 2. Subscribing to Channels
    3. 3. Unsubscribing from Channels
    4. 4. Using Pattern Subscriptions
    5. 5. Using Sharded Pub/Sub
    6. 6. Listing Active Channels
    7. 7. Counting Subscribers
    8. 8. Counting Pattern Subscribers
    9. 9. Understanding Message Delivery Guarantees
    10. 10. Handling Connection Issues
    11. 11. Implementing Fan-Out Pattern
    12. Example: Broadcast event to all listeners

  20. Optimizing with Pipelining

    1. 1. Understanding Pipeline Concept
    2. 2. Implementing Pipeline in Clients
    3. Example: Pipeline in Jedis
    4. 3. Batching Multiple Commands
    5. 4. Handling Pipeline Responses
    6. 5. Comparing Pipelining vs Transactions
    7. Pipeline
    8. Transaction (MULTI/EXEC)
    9. 6. Understanding Round-Trip Time Savings
    10. 7. Measuring Performance Gains
    11. 8. Using Pipeline with Lua Scripts
    12. 9. Managing Pipeline Buffer Size
    13. 10. Avoiding Pipeline Pitfalls

  21. Implementing Caching Strategies

    1. 1. Using Cache-Aside Pattern
    2. Example: Lookup with cache-aside
    3. 2. Using Write-Through Pattern
    4. 3. Using Write-Behind Pattern
    5. 4. Implementing TTL-Based Expiration
    6. 5. Handling Cache Invalidation
    7. 6. Using Probabilistic Early Expiration
    8. Example: XFetch algorithm
    9. 7. Implementing Cache Warming
    10. 8. Preventing Cache Stampede
    11. 9. Using Lazy Loading
    12. 10. Implementing Cache Key Patterns
    13. 11. Using Cache Tagging
    14. 12. Implementing Cache Versioning

  22. Implementing Distributed Locks

    1. 1. Setting Lock with SETNX
    2. 2. Using SET with NX and EX Options
    3. 3. Implementing Lock Expiration
    4. 4. Releasing Locks Safely (Lua Script)
    5. Example: Token-checked release
    6. 5. Handling Lock Timeouts
    7. 6. Implementing Redlock Algorithm
    8. 7. Preventing Deadlocks
    9. 8. Using WATCH for Optimistic Locking
    10. 9. Handling Lock Renewal
    11. Example: Renewal Lua
    12. 10. Understanding Lock Granularity

  23. Implementing Rate Limiting

    1. 1. Implementing Fixed Window Counter
    2. Example: 100 req/min per user
    3. 2. Implementing Sliding Window Counter
    4. 3. Using Token Bucket Algorithm
    5. Example: Token bucket via Lua
    6. 4. Using Sorted Sets for Sliding Windows
    7. 5. Using Sliding Window Log Algorithm
    8. 6. Implementing Leaky Bucket Pattern
    9. 7. Setting Rate Limit Expiration
    10. 8. Implementing Distributed Rate Limiting
    11. 9. Handling Race Conditions
    12. 10. Optimizing with Lua Scripts

  24. Implementing Time Series Data

    1. 1. Using Sorted Sets for Time Series
    2. 2. Storing Timestamped Data
    3. 3. Querying by Time Range
    4. 4. Aggregating Time Series Data
    5. 5. Implementing Downsampling
    6. 6. Setting Data Retention Policies
    7. 7. Using EXPIRE for Auto-Cleanup
    8. 8. Handling High-Frequency Updates
    9. 9. Using RedisTimeSeries Module
    10. 10. Implementing Compaction Strategies

  25. Working with Bloom Filters

    1. 1. Adding Elements to Bloom Filter
    2. 2. Checking Element Existence
    3. 3. Adding Multiple Elements
    4. 4. Checking Multiple Elements
    5. 5. Creating Custom Bloom Filter
    6. 6. Getting Filter Info
    7. 7. Understanding False Positive Rate
    8. 8. Configuring Filter Capacity and Error Rate
    9. 9. Using for Duplicate Detection
    10. Example: De-dup processed events
    11. 10. Comparing with Set-Based Membership Testing
    12. Bloom Filter
    13. SET

  26. Working with Cuckoo Filters

    1. 1. Adding Elements to Filter
    2. 2. Checking Element Existence
    3. 3. Deleting Elements from Filter
    4. 4. Adding if Not Exists
    5. 5. Creating Custom Cuckoo Filter
    6. 6. Getting Filter Info
    7. 7. Understanding Deletion Support
    8. 8. Configuring Filter Capacity
    9. 9. Comparing with Bloom Filters
    10. Cuckoo
    11. Bloom
    12. 10. Using for Space-Efficient Sets

  27. Working with JSON Documents

    1. 1. Setting JSON Documents
    2. 2. Getting JSON Values
    3. 3. Deleting JSON Keys
    4. 4. Using JSONPath Queries
    5. 5. Handling Nested Objects
    6. 6. Getting Object Keys
    7. 7. Getting Object Length
    8. 8. Incrementing Numeric Values
    9. 9. Appending to Strings
    10. 10. Getting String Length
    11. 11. Appending to Arrays
    12. 12. Getting Array Length
    13. 13. Inserting Array Elements
    14. 14. Popping Array Elements
    15. 15. Trimming Arrays

  28. Configuring Persistence with RDB

    1. 1. Understanding RDB Snapshots
    2. 2. Configuring Save Points
    3. 3. Triggering Manual Save
    4. 4. Setting RDB Filename
    5. 5. Setting RDB Directory
    6. 6. Getting Last Save Time
    7. 7. Configuring Compression
    8. 8. Enabling Checksum
    9. 9. Handling RDB Failures
    10. 10. Understanding Fork Performance Impact
    11. 11. Using RDB for Backups
    12. 12. Tuning Save Intervals

  29. Configuring Persistence with AOF

    1. 1. Understanding AOF Concept
    2. 2. Enabling AOF
    3. 3. Setting AOF Filename
    4. 4. Configuring Fsync Policy
    5. 5. Rewriting AOF (BGREWRITEAOF)
    6. 6. Auto-Rewrite Configuration
    7. 7. Enabling Mixed Persistence
    8. 8. Handling AOF Corruption
    9. 9. Understanding AOF vs RDB Tradeoffs
    10. AOF
    11. RDB
    12. 10. Managing AOF File Growth
    13. 11. Understanding Fsync Performance Impact
    14. 12. Recovering from AOF Files

  30. Implementing Replication

    1. 1. Configuring Master Server
    2. 2. Configuring Replica Server
    3. 3. Setting Replica Read-Only
    4. 4. Checking Replication Status
    5. 5. Promoting Replica to Master
    6. 6. Configuring Diskless Replication
    7. 7. Setting Replication Timeout
    8. 8. Enabling Partial Resync
    9. 9. Using WAIT for Synchronous Replication
    10. 10. Using WAITAOF for AOF Sync
    11. 11. Handling Replication Lag
    12. 12. Monitoring Replication Offset
    13. 13. Using Replicas for Read Scaling

  31. Implementing Redis Sentinel

    1. 1. Understanding Sentinel Architecture
    2. 2. Configuring Sentinel Instances
    3. 3. Monitoring Master Instances
    4. 4. Setting Quorum Requirements
    5. 5. Configuring Automatic Failover
    6. 6. Configuring Down-After-Milliseconds
    7. 7. Understanding Parallel-Syncs Setting
    8. 8. Getting Sentinel Info
    9. 9. Getting Master Address
    10. 10. Manual Failover
    11. 11. Adding and Removing Sentinels
    12. 12. Monitoring Sentinel Events

  32. Managing Redis Cluster

    1. 1. Understanding Cluster Architecture
    2. 2. Creating Cluster Nodes
    3. 3. Joining Cluster
    4. 4. Adding Slots to Nodes
    5. 5. Migrating Slots
    6. 6. Getting Cluster Info
    7. 7. Listing Cluster Nodes
    8. 8. Understanding Hash Slot Distribution
    9. Example: Hashtag pins keys to one slot
    10. 9. Configuring Cluster Replicas
    11. 10. Handling Cluster Failover
    12. 11. Resharding Cluster
    13. 12. Monitoring Cluster Health
    14. 13. Using Cluster-Aware Clients
    15. 14. Handling Network Partitions

  33. Implementing Security and Authentication

    1. 1. Setting Password
    2. 2. Authenticating Clients
    3. 3. Binding to Specific Interfaces
    4. 4. Enabling Protected Mode
    5. 5. Disabling Dangerous Commands
    6. 6. Using TLS/SSL Encryption
    7. 7. Configuring TLS Certificates
    8. 8. Validating Client Certificates
    9. 9. Using Mutual TLS Authentication
    10. 10. Configuring TLS Protocols and Ciphers

  34. Managing Access Control Lists

    1. 1. Creating ACL Users
    2. 2. Listing ACL Users
    3. 3. Getting User Details
    4. 4. Deleting ACL Users
    5. 5. Setting User Passwords
    6. 6. Enabling and Disabling Users
    7. 7. Granting Command Permissions
    8. 8. Using ACL Categories and Subcommands
    9. 9. Restricting Key Patterns
    10. 10. Loading ACL from File
    11. 11. Saving ACL Configuration
    12. 12. Checking Current User
    13. 13. Logging ACL Events

  35. Managing Client Connections

    1. 1. Listing Connected Clients
    2. 2. Getting Client Name
    3. 3. Setting Client Name
    4. 4. Getting Client Info
    5. 5. Using CLIENT ID for Tracking
    6. 6. Killing Client Connections
    7. 7. Pausing All Clients
    8. 8. Unblocking Clients
    9. 9. Using CLIENT NO-EVICT
    10. 10. Using CLIENT NO-TOUCH
    11. 11. Tracking Client Side Caching
    12. 12. Implementing Client-Side Caching Invalidation
    13. Example: BCAST tracking with prefix

  36. Implementing Connection Management

    1. 1. Pinging Server
    2. 2. Echoing Messages
    3. 3. Selecting Database
    4. 4. Quitting Connection
    5. 5. Setting Connection Timeout
    6. 6. Configuring TCP Keepalive
    7. 7. Managing Max Clients
    8. 8. Using HELLO for Protocol Negotiation
    9. 9. Using RESP3 Protocol
    10. 10. Implementing Connection Pooling

  37. Optimizing Memory Usage

    1. 1. Measuring Memory Consumption
    2. 2. Setting Max Memory
    3. 3. Configuring Memory Policies
    4. 4. Using Smaller Encodings
    5. 5. Reducing Key Size
    6. 6. Sharing Common Strings
    7. 7. Using Hash Field Expiration
    8. 8. Avoiding Large Keys
    9. 9. Compressing Values
    10. 10. Using EXPIRE for Cleanup
    11. 11. Analyzing Memory with MEMORY USAGE
    12. 12. Sampling Memory Statistics

  38. Configuring Eviction Policies

    1. 1. Understanding Eviction Policies
    2. 2. Using NoEviction Policy
    3. 3. Using AllKeys-LRU Policy
    4. 4. Using Volatile-LRU Policy
    5. 5. Using AllKeys-LFU Policy
    6. 6. Using Volatile-LFU Policy
    7. 7. Using AllKeys-Random Policy
    8. 8. Using Volatile-Random Policy
    9. 9. Using Volatile-TTL Policy
    10. 10. Configuring LFU Parameters
    11. 11. Monitoring Eviction Statistics

  39. Monitoring and Debugging

    1. 1. Getting Server Info
    2. 2. Monitoring Real-Time Commands
    3. 3. Using SLOWLOG
    4. 4. Configuring Latency Monitor
    5. 5. Using DEBUG Command
    6. 6. Profiling Performance
    7. 7. Tracking Client Statistics
    8. 8. Monitoring Replication Stats
    9. 9. Debugging Slow Queries
    10. 10. Using Redis CLI Tools

  40. Optimizing Performance

    1. 1. Using Pipelining Effectively
    2. 2. Avoiding Large Operations
    3. 3. Using SCAN Instead of KEYS
    4. 4. Using UNLINK for Large Keys
    5. 5. Enabling Lazy Free
    6. 6. Configuring IO Threads
    7. 7. Tuning TCP Parameters
    8. 8. Disabling Transparent Huge Pages
    9. 9. Configuring Kernel Parameters
    10. 10. Using CONFIG SET for Runtime Changes
    11. 11. Benchmarking with redis-benchmark
    12. 12. Optimizing Network Latency

  41. Working with Server Administration

    1. 1. Getting Server Time
    2. 2. Getting Role Information
    3. 3. Saving Database
    4. 4. Getting Last Save Time
    5. 5. Rewriting AOF
    6. 6. Syncing Data to Disk
    7. 7. Shutting Down Server
    8. 8. Debugging Objects
    9. 9. Setting Server Verbosity
    10. 10. Resetting Statistics
    11. 11. Getting Command Info
    12. 12. Using MODULE LOAD for Extensions

  42. Testing Redis Operations

    1. 1. Using Redis CLI for Testing
    2. 2. Implementing Unit Tests
    3. 3. Using Redis Mock Libraries
    4. 4. Testing Transactions
    5. 5. Testing Lua Scripts
    6. 6. Benchmarking Performance
    7. 7. Using --intrinsic-latency for Baseline Testing
    8. 8. Load Testing with Multiple Clients
    9. 9. Testing Failover Scenarios
    10. 10. Validating Data Integrity
    11. 11. Testing Cluster Resharding
    12. 12. Simulating Network Partitions

  43. Troubleshooting Common Issues

    1. 1. Debugging Connection Timeouts
    2. 2. Resolving Memory Overflow Errors
    3. 3. Handling Out-of-Memory Errors
    4. 4. Handling Slow Query Performance
    5. 5. Fixing Replication Lag
    6. 6. Resolving Cluster Split-Brain
    7. 7. Debugging Cluster Node Failures
    8. 8. Debugging Lua Script Errors
    9. 9. Fixing Persistence Failures
    10. 10. Resolving AOF Corruption
    11. 11. Debugging Client Blocking Issues
    12. 12. Fixing Network Connectivity Issues
    13. 13. Resolving Authentication Failures
    14. 14. Handling Eviction Policy Issues