Redis - In-Memory Data Store

Official site: https://redis.io
GitHub: https://github.com/redis/redis (74K+ stars)
Documentation: https://redis.io/docs

# Option 1: Docker (recommended for development)
docker run -d -p 6379:6379 redis:latest

# Option 2: Homebrew (macOS/Linux)
brew install redis
brew services start redis

# Option 3: APT (Debian/Ubuntu)
sudo apt update
sudo apt install redis-server
sudo systemctl start redis-server

# Option 4: YUM (RHEL/CentOS/Fedora)
sudo yum install redis
sudo systemctl start redis

# Option 5: Snap
sudo snap install redis --classic

# Verify installation
redis-cli ping
# Should return: PONG

# Install dependencies
sudo apt update
sudo apt install -y gcc make wget curl

# Clone Redis repository
git clone --depth 1 https://github.com/redis/redis.git
cd redis

# Build with all features (including modules)
make BUILD_WITH_MODULES=yes

# Run tests (optional but recommended)
make test

# Install system-wide (with modules)
sudo make install PREFIX=/usr/local

# Copy config file
sudo cp redis.conf /etc/redis/
sudo mkdir -p /var/lib/redis
sudo chown -R $USER:$USER /etc/redis /var/lib/redis

# Start Redis
redis-server /etc/redis/redis.conf

# Verify
redis-cli ping
# Output: PONG

# Check version
redis-cli INFO server | grep redis_version

# Basic secure configuration for production
port 6379
bind 127.0.0.1
protected-mode yes
requirepass your-secure-password-here

# Memory management
maxmemory 2gb
maxmemory-policy allkeys-lru

# Persistence
save 900 1
save 300 10
save 60 10000
appendonly yes
appendfsync everysec

# Performance
tcp-backlog 511
timeout 0
tcp-keepalive 300

# Data directory
dir ./

# Database count
databases 16

# Start Redis CLI
redis-cli

# Basic string operations
redis> SET mykey "Hello World"
OK
redis> GET mykey
"Hello World"
redis> EXPIRE mykey 60
(integer) 1

# Counter (great for tracking)
redis> SET page_views 0
OK
redis> INCR page_views
(integer) 1
redis> INCRBY page_views 100
(integer) 101

# Hash (user data)
redis> HSET user:1000 name "Alice"
(integer) 1
redis> HSET user:1000 email "alice@example.com"
(integer) 1
redis> HGETALL user:1000
1) "name"
2) "Alice"
3) "email"
4) "alice@example.com"

# List (queue)
redis> LPUSH tasks "task1"
(integer) 1
redis> LPUSH tasks "task2"
(integer) 2
redis> RPOP tasks
"task1"

# Set (unique items)
redis> SADD tags:post:1 "redis" "caching" "database"
(integer) 3
redis> SMEMBERS tags:post:1
1) "redis"
2) "caching"
3) "database"
redis> SISMEMBER tags:post:1 "redis"
(integer) 1

# Sorted Set (leaderboard)
redis> ZADD leaderboard 100 "Alice"
(integer) 1
redis> ZADD leaderboard 150 "Bob"
(integer) 1
redis> ZADD leaderboard 120 "Charlie"
(integer) 1
redis> ZRANGE leaderboard 0 -1 WITHSCORES
1) "Alice"
2) "100"
3) "Charlie"
4) "120"
5) "Bob"
6) "150"

# Exit
redis> EXIT

# Enable JSON module if needed (after building with modules)
# Then use JSON commands:

# Store JSON document
redis> JSON.SET user:1000 $ '{"name":"Alice","age":30,"skills":["redis","nodejs"]}'
OK

# Get entire document
redis> JSON.GET user:1000
{"name":"Alice","age":30,"skills":["redis","nodejs"]}

# Get specific field
redis> JSON.GET user:1000 $.name
["Alice"]

# Update nested value
redis> JSON.SET user:1000 $.age 31
OK

# Add array element
redis> JSON.ARRAPPEND user:1000 $.skills "python"
(integer) 4

# Query with aggregation
redis> JSON.GET user:1000 '.*'

# Create stream with messages
redis> XADD mystream * field1 "value1" field2 "value2"
"1635791234567-0"
redis> XADD mystream * field1 "value3" field2 "value4"
"1635791234568-0"

# Read stream
redis> XREAD COUNT 2 BLOCK 0 STREAMS mystream 0
1) 1) "mystream"
2)  1)  1) "1635791234567-0"
     2)  1) "field1"
          2) "value1"
          3) "field2"
          4) "value2"
     2)  1) "1635791234568-0"
          2)  1) "field1"
              2) "value3"
              3) "field2"
              4) "value4"

# Create consumer group
redis> XGROUP CREATE mystream mygroup $ MKSTREAM
OK

# Read from consumer group
redis> XREADGROUP GROUP mygroup consumer1 COUNT 1 STREAMS mystream >
1) 1) "mystream"
2)  1)  1) "1635791234567-0"
     2)  1) "field1"
          2) "value1"
          3) "field2"
          4) "value2"

# Acknowledge message
redis> XACK mystream mygroup "1635791234567-0"
(integer) 1

# Terminal 1: Subscribe to channel
redis-cli
> SUBSCRIBE news
Reading messages on 'news'

# Terminal 2: Publish message
redis-cli
> PUBLISH news "Breaking news: Redis is awesome!"
(integer) 1

# Terminal 1 receives:
# 1) "subscribe"
# 2) "news"
# 3) "Breaking news: Redis is awesome!"

# Pattern subscriptions (multiple channels)
redis-cli
> PSUBSCRIBE news:* sports:*
Reading messages on 'news:*' and 'sports:*'

redis-cli
> PUBLISH news:local "Local news update"
(integer) 1
> PUBLISH news:world "World news update"
(integer) 1

# Simple transaction
redis> MULTI
OK
redis> INCR counter:1
QUEUED
redis> INCR counter:2
QUEUED
redis> SET mykey "transactional value"
QUEUED
redis> EXEC
1) (integer) 1
2) (integer) 1
3) "OK"

# Watch for changes (optimistic locking)
redis> WATCH mykey
OK
redis> MULTI
OK
redis> INCR mykey
QUEUED
redis> EXEC
1) (integer) 2

# If another client modified mykey between WATCH and EXEC:
# EXEC returns nil (transaction aborted)

# Discard transaction
redis> MULTI
OK
redis> SET key "value"
QUEUED
redis> DISCARD
OK
# Nothing was executed

# Simple Lua script (increment with condition)
redis> EVAL "if tonumber(ARGV[1]) > 0 then return redis.call('INCR', KEYS[1]) else return redis.call('DECR', KEYS[1]) end" 1 mycounter 5
(integer) 11

# Complex: atomic check-and-set
redis> EVAL "if not redis.call('EXISTS', KEYS[1]) then redis.call('SET', KEYS[1], ARGV[1], 'EX', ARGV[2]); return 1; else return 0; end" 1 cache:key "value" 3600
(integer) 1

# Store and reuse scripts (SHA1)
redis> SCRIPT LOAD "return redis.call('GET', KEYS[1])"
"9a0568f33435c3a0e6c5e7c6e8e9e1e2e3e4e5e6"
redis> EVALSHA "9a0568f33435c3a0e6c5e7c6e8e9e1e2e3e4e5e6" 1 mykey

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

const redis = require('redis');
const client = redis.createClient();
await client.set('key', 'value');
console.log(await client.get('key'));

import "github.com/go-redis/redis/v8"
rdb := redis.NewClient(&redis.Options{Addr: ":6379"})
rdb.Set(ctx, "key", "value", 0)
val, _ := rdb.Get(ctx, "key").Result()

Jedis jedis = new Jedis("localhost", 6379);
jedis.set("key", "value");
String value = jedis.get("key");

Python: pip install redis
Node.js: npm install redis
Go: go get github.com/go-redis/redis/v8
Java: Maven - org.redisson:redisson
C#: dotnet add package StackExchange.Redis
PHP: composer require predis/predis
Ruby: gem install redis

Full list: https://redis.io/docs/latest/develop/clients/

# Python Flask example
from flask import Flask, session
app = Flask(__name__)
app.secret_key = 'your-secret'
app.config.update(
    SESSION_COOKIE_SECURE=True,
    SESSION_COOKIE_HTTPONLY=True,
)
# Configure Redis for sessions
from flask_session import Session
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.from_url('redis://localhost:6379')

# Add score
zadd('leaderboard', {player_id: score})

# Get top 10
zrevrange('leaderboard', 0, 9, withscores=True)

# Get player rank
zrevrank('leaderboard', player_id)

def get_user(user_id):
    cache_key = f'user:{user_id}'
    cached = redis.get(cache_key)
    if cached:
        return json.loads(cached)
    # Query database
    user = db.query('SELECT * FROM users WHERE id = ?', user_id)
    redis.setex(cache_key, 3600, json.dumps(user))
    return user

def rate_limit(key, max_requests, window_seconds):
    count = redis.incr(f'ratelimit:{key}')
    if count == 1:
        redis.expire(f'ratelimit:{key}', window_seconds)
    return count <= max_requests

# Producer
redis.lpush('jobs', json.dumps(job_data))

# Consumer
while True:
    job = redis.rpop('job', timeout=1)
    if job:
        process_job(job)

# Count page views
redis.incr('views:page:home')

# Unique visitors (HyperLogLog)
redis.pfadd('unique:visitors', user_id)
redis.pfcount('unique:visitors')

# Percentile calculations (T-Digest module)
TDIGEST.ADD latency:api 123.45
TDIGEST.QUANTILE latency:api 0.5 0.9 0.95

import redis.lock
with redis.lock.Lock(
    client=redis,
    name='critical-resource',
    timeout=10,
    blocking=True,
    blocking_timeout=5
) as lock:
    # Critical section
    pass

# Store vector embeddings
ft.create_index(
    ['vector'],
    schema=[Field('vector', 'VECTOR', 'HNSW', 'FLOAT32')]
)

# Semantic similarity search
ft.search('(@vector:[KNN 10 @vector $bvec])',
          params={'bvec': binary_vector},
          return_fields=['__vector_score'])

# Installation for examples
pip install redis flask redis-py

# For vector search (Redis Stack)
pip install redis-stack

# For AI workloads
pip install redisvl

# Redis config (redis.conf)

# RDB snapshots
save 900 1      # Save after 900 sec if 1 key changed
save 300 10     # Save after 300 sec if 10 keys changed
save 60 10000   # Save after 60 sec if 10000 keys changed
dbfilename dump.rdb
dir ./

# AOF persistence
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec   # fsync every second (balance)
# appendfsync always     # fsync on every write (safest)
# appendfsync no         # let OS handle fsync (fastest)

# AOF rewrite (compact AOF)
aof-use-rdb-preamble yes
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# Load priority on restart
stop-writes-on-bgsave-error no
rdb-save-background-saves-enabled yes

# Security hardening (redis.conf)

# Network
bind 127.0.0.1
protected-mode yes
port 6379

# Authentication
requirepass "strong-random-password-min-32-chars"

# Rename dangerous commands
rename-key FLUSHALL ""
rename-key FLUSHDB ""
rename-key CONFIG ""
rename-key DEBUG ""
rename-key SHUTDOWN ""

# TLS (optional but recommended)
tls-port 6379
tls-cert-file /etc/redis/redis.crt
tls-key-file /etc/redis/redis.key
tls-ca-cert-file /etc/redis/ca.crt

# Resource limits
maxmemory 2gb
maxmemory-policy allkeys-lru
maxclients 10000

# Disable dangerous modules
loadmodule /path/to/module.so

# Check server info
redis-cli INFO

# Memory usage
redis-cli INFO memory | grep used_memory_human
# Output: used_memory_human:256.19Mb

# Key count
redis-cli DBSIZE
# Output: 1523

# Slow queries
redis-cli SLOWLOG GET 10

# Memory per key (Redis 4.0+)
redis-cli --bigkeys

# Search for keys pattern
redis-cli --scan --pattern "user:*" | head -20

# Delete expired keys manually (if needed)
redis-cli KEYS "expired:*" | xargs redis-cli DEL

# Monitor connections
redis-cli INFO clients

# Check persistence status
redis-cli INFO persistence

# Top memory consumers (requires redis-memory-command)
redis-cli MEMORY STATS

# Setup replica (redis.conf)
replicaof master-IP master-port
masterauth "master-password"

# Start replica
redis-server /etc/redis/replica.conf

# Verify replication
redis-cli INFO replication
# Output:
# role:master
# connected_slaves:2
# slave0:ip=10.0.0.2,port=6379,state=online
# slave1:ip=10.0.0.3,port=6379,state=online

# Check replica lag
redis-cli -h replica-IP latency histogram

# Test failover (manual)
redis-cli -h master-IP SLAVEOF NO ONE
redis-cli -h replica-IP INFO replication

# Redis Cluster (3 masters + 3 replicas)
redis-server --cluster-enabled yes --cluster-config-file nodes.conf
redis-cli --cluster create \n    127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 \n    127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 \n    --cluster-replicas 1

AWS ElastiCache: https://aws.amazon.com/elasticache/
Google Memorystore: https://cloud.google.com/memorystore
Azure Cache: https://azure.microsoft.com/en-us/products/cache-for-redis/
Redis Cloud: https://redis.io/cloud/

GitHub: https://github.com/redis/redis
Official site: https://redis.io
Documentation: https://redis.io/docs
Redis Stack (with modules): https://redis.io/docs/latest/develop/oss/redis-stack/