Redis — The High-Performance In-Memory Data Store

Introduction

Redis (Remote Dictionary Server) is the most widely used in-memory data store in the world. Originally created by Salvatore Sanfilippo in 2009, it provides blazing-fast data access with sub-millisecond latency, making it the go-to solution for caching, session management, real-time analytics, message queuing, and rate limiting.

With over 74,000 GitHub stars, Redis is used by virtually every major technology company. Its versatility as a cache, database, and message broker — combined with its simplicity and performance — has made it an essential component of modern application architectures.

What Redis Does

Redis stores data in memory as key-value pairs, but goes far beyond simple strings. It supports rich data structures — lists, sets, sorted sets, hashes, streams, and geospatial indexes — each with specialized commands. This makes Redis suitable for use cases ranging from simple caching to complex real-time applications.

Architecture Overview

[Clients]
redis-cli, application SDKs
(Python, Node.js, Java, Go...)
        |
   [Redis Server]
   Single-threaded event loop
   (I/O multiplexing)
        |
   [In-Memory Data Store]
   +-------+-------+-------+
   |       |       |       |
[Strings] [Lists]  [Sets]  [Hashes]
[Sorted   [Streams] [Geo]  [HyperLogLog]
 Sets]    [Bitmaps] [JSON]  [Vectors]
        |
   [Persistence]
   RDB snapshots + AOF log
        |
   [Clustering]
   Redis Cluster for
   horizontal scaling
   Redis Sentinel for HA

Self-Hosting & Configuration

# redis.conf — key configuration
# Memory
maxmemory 2gb
maxmemory-policy allkeys-lru

# Persistence
save 900 1      # RDB: save after 900s if 1+ keys changed
save 300 10     # save after 300s if 10+ keys changed
appendonly yes  # Enable AOF persistence

# Security
requirepass your-strong-password

# Network
bind 0.0.0.0
port 6379

# Python usage
import redis

r = redis.Redis(host="localhost", port=6379, decode_responses=True)

# Basic operations
r.set("user:1:name", "Alice", ex=3600)  # expires in 1 hour
name = r.get("user:1:name")

# Hash (like a mini-document)
r.hset("user:1", mapping={"name": "Alice", "email": "alice@example.com"})
user = r.hgetall("user:1")

# Sorted set (leaderboard)
r.zadd("scores", {"player1": 100, "player2": 250, "player3": 75})
top = r.zrevrange("scores", 0, 2, withscores=True)

# Pub/Sub
r.publish("notifications", "New order received")

Key Features

• Sub-Millisecond Latency — in-memory storage with 100K+ ops/sec
• Rich Data Structures — strings, lists, sets, sorted sets, hashes, streams
• Persistence — RDB snapshots and AOF log for durability
• Pub/Sub — real-time messaging between publishers and subscribers
• Streams — append-only log for event sourcing and message queues
• Clustering — horizontal scaling with automatic sharding
• Lua Scripting — atomic server-side operations
• Vector Search — built-in vector similarity search for AI applications

Comparison with Similar Tools

FAQ

Q: Redis vs Memcached — which should I use? A: Redis for almost all use cases. Memcached only if you need pure string caching with multi-threaded simplicity. Redis provides richer data structures, persistence, pub/sub, and clustering.

Q: What happened with the Redis license change? A: In 2024, Redis changed from BSD to RSALv2/SSPL dual license. This led to the Valkey fork (backed by Linux Foundation) as a fully open-source alternative. Both are actively maintained.

Q: How do I handle cache invalidation? A: Use TTL (expiration) for time-based invalidation, pub/sub for event-based invalidation, or the WATCH/MULTI/EXEC transaction pattern for optimistic locking.

Q: Can Redis be used as a primary database? A: Yes, with persistence enabled (RDB + AOF). Redis provides durability guarantees suitable for primary storage. However, for complex queries and relational data, a traditional database is better.

Sources

• GitHub: https://github.com/redis/redis
• Documentation: https://redis.io/docs
• Created by Salvatore Sanfilippo
• License: RSALv2 / SSPLv1