Redis

Redis (Remote Dictionary Server) is an open-source, in-memory data structure store used as a database, cache, message broker, and streaming engine. Unlike traditional disk-based databases, Redis stores data in RAM, delivering sub-millisecond response times and supporting millions of operations per second. Redis supports rich data structures beyond simple key-value pairs—strings, hashes, lists, sets, sorted sets, bitmaps, hyperloglogs, geospatial indexes, and streams. Its speed, simplicity, and versatility make Redis the most popular in-memory database, powering caching, session storage, real-time analytics, leaderboards, pub/sub messaging, and job queues.

Best For:
Redis excels for applications requiring ultra-fast data access where milliseconds matter. It's ideal for caching database query results to reduce load and improve performance, storing user sessions for web applications, building real-time leaderboards and counters, implementing pub/sub messaging systems, managing job queues for background processing, and powering real-time analytics dashboards. Redis works particularly well as a complementary technology alongside traditional databases like PostgreSQL or MongoDB, handling hot data while slower databases handle persistent storage.

Common Questions

When should I use Redis instead of PostgreSQL or MongoDB?
Redis is not a replacement for traditional databases—it's complementary. Use Redis for temporary data, caching, and real-time operations requiring extreme speed (sub-millisecond latency). Use PostgreSQL/MySQL/MongoDB for persistent data requiring complex queries, transactions, and data durability guarantees. Common pattern: store primary data in PostgreSQL, cache frequently accessed data in Redis for speed. Redis trades persistence and query complexity for speed; traditional databases trade speed for rich querying and guaranteed durability.

Does Redis persist data to disk?
Yes, Redis offers configurable persistence: RDB (snapshotting) saves full dataset at intervals, and AOF (append-only file) logs every write operation. However, Redis is primarily an in-memory store—persistence is for crash recovery, not primary storage. Some data loss is possible between snapshots. For mission-critical data requiring zero loss, use traditional databases. Redis is best for data you can afford to lose or regenerate (caches, sessions, temporary computations).

How much does Redis cost?
Redis open-source is 100% free with no limitations. Costs come from infrastructure (servers with enough RAM to hold your dataset). Managed Redis services charge for memory and features: AWS ElastiCache starts ~$15/month for 1.5 GB RAM, scaling to thousands monthly for large deployments. Redis Enterprise (commercial version by Redis Inc.) offers clustering, active-active geo-replication, and enhanced security at custom enterprise pricing. Most small-to-medium applications run free open-source Redis on their own servers or inexpensive cloud VMs.

Can Redis handle large datasets?
Redis can handle terabytes of data with Redis Cluster (sharding across multiple nodes). However, your dataset must fit in RAM, which is more expensive than disk storage. A 100 GB Redis dataset requires 100+ GB RAM (~$100-500/month on cloud). For very large datasets where speed isn't critical, traditional databases are more cost-effective. Redis is ideal for hot data (frequently accessed subset) while cold data lives in disk-based databases.

Pricing & Plans

Redis Open Source (Free): Complete in-memory data store with unlimited data (within your RAM), all data structures, pub/sub, Lua scripting, persistence options (RDB/AOF), clustering, and replication. Free forever under BSD license. Self-host on your infrastructure.

Managed Redis Services:

• AWS ElastiCache: $0.017-2.352/hour ($12-1,700/month) depending on instance size (1.5 GB - 317 GB RAM). Automatic backups, Multi-AZ replication.
• Google Cloud Memorystore: $0.049-0.342/GB/hour (~$36-250/GB/month). Fully managed with automatic failover.
• Azure Cache for Redis: Basic ($0.02/hour ~$15/month), Standard ($0.074/hour), Premium ($0.60+/hour) with clustering and persistence.
• Redis Cloud (Redis Inc.): Free 30 MB tier, paid plans from $5/month (250 MB) to thousands for enterprise features like active-active geo-replication.

Redis Enterprise: Custom pricing for on-premises or cloud deployments with advanced features, 24/7 support, and SLAs. Typically $10,000-100,000+/year for enterprise deployments.

Limitations

Redis's primary limitation is RAM cost—all data must fit in memory, which is 5-10x more expensive than disk storage per GB. Large datasets become prohibitively expensive compared to disk-based databases. While Redis offers persistence (RDB/AOF), it's not as durable as traditional databases—there's a small window for data loss between snapshots. Redis uses single-threaded architecture (one CPU core per instance), limiting performance scaling on single nodes; clustering is required for true horizontal scaling. Redis's query capabilities are limited—no SQL, joins, or complex filtering like relational databases. Each Redis instance must fit on one server's RAM (clustering distributes keys, not individual datasets). Redis Cluster doesn't support multiple databases or advanced features available in standalone mode.

Getting Started

Install Redis locally: macOS (brew install redis), Ubuntu (sudo apt install redis-server), or Docker (docker run -d -p 6379:6379 redis). Start server: redis-server. Connect via CLI: redis-cli. Basic commands:

# Set/get string
SET name "John"
GET name

# Increment counter
SET counter 100
INCR counter

# Hash (object)
HSET user:1 name "Alice" age 30
HGET user:1 name

# List
LPUSH tasks "task1" "task2"
LRANGE tasks 0 -1

# Set expiration (cache)
SET session:abc "data" EX 3600  # expires in 1 hour

Use Redis from your application (Python example: pip install redis):

import redis
r = redis.Redis(host='localhost', port=6379)
r.set('key', 'value')
print(r.get('key'))

Configure persistence in redis.conf (RDB snapshots or AOF logging). Set maxmemory limit and eviction policy (LRU, LFU) for cache use cases. Use Redis Cluster for datasets exceeding single-server RAM. Monitor with redis-cli INFO and tools like RedisInsight (free GUI). Complete Redis University's free courses (RU101, RU102) for comprehensive training. Practice common patterns: caching, session storage, rate limiting, leaderboards.