1. What is Redis — and Why Should You Care?

Redis (Remote Dictionary Server) is a powerful, extremely fast in-memory data store that persists data as key-value pairs. The killer feature is that the value isn't limited to a simple string — it can be one of five rich data structures (Strings, Lists, Sets, Sorted Sets, Hashes), making Redis a genuine multi-paradigm engine rather than just a dumb cache.

Replication — Master/Slave Architecture

Redis supports master–replica (formerly master–slave) replication. The master propagates all writes to one or more replicas synchronously or asynchronously. If the master dies, a replica can be promoted to take over — a critical pattern for production HA setups. Combine with Redis Sentinel or Redis Cluster for automatic failover.

Key Characteristics

Open-source NoSQL store. No built-in indexing out of the box (though you can build secondary indexes using Sorted Sets). No SQL query language, but Lua scripting gives you server-side logic equivalent to PL/SQL stored procedures without round-trips. Data can be optionally persisted to disk via RDB snapshots or AOF (Append-Only File) logging.

2. SQL vs NoSQL — Choosing Deliberately

Redis sits firmly in the NoSQL world. Here's a crisp decision framework:

3. Where Redis Actually Shines

Redis's in-memory nature makes it the right tool for latency-sensitive, high-throughput operations. Common production patterns:

For geospatial applications: Redis's GEOADD / GEODIST / GEORADIUS commands let you store lat/long coordinates and find objects within a radius — a feature set that would require PostGIS or external services otherwise. It's a genuinely underrated use case.

4. The Five Data Types, In Depth

Strings — Full Command Reference

# Basic get/set
SET    name    Jesse
SET    hobby   "Computer reading"
GET    name
APPEND name    " is my name!"

# Numeric operations
INCRBY  age 5     # increment by 5
INCR    age       # increment by 1
DECR    age
DECRBY  age 10

# Bulk operations
MSET   mammal whale insect "June bug"
MGET   mammal insect

# Key management
SETNX  name Jesse   # set only if key doesn't exist
MSETNX mammal pig fish salmon  # atomic multi-set if none exist
RENAME name newname
EXISTS name
DEL    name
TYPE   age           # returns the type of value
TTL    animal        # time to live (-1 = no expiry)

# Expiry
EXPIRE  animal 5000  # set TTL in milliseconds
PERSIST animal       # remove expiry

# Utility
KEYS   *            # list all keys (avoid in prod)
KEYS   na*          # wildcard search
FLUSHDB             # remove all keys from current db
FLUSHALL            # remove all keys from ALL dbs

Hashes

HSET    people   john 12
HMSET   people   kim 9   ted 12   ben 13
HGETALL people
HGET    people   john
HMGET   people   sam kim
HDEL    people   ben
HLEN    people
HKEYS   people
HVALS   people
HINCRBY scores   u2 5
HEXISTS people   u4

Lists

Unlike Sets, Lists are ordered and allow duplicates. They're implemented as doubly-linked lists — constant time for push/pop at either end, but O(n) for index access.

LPUSH   colors   red green blue   # push left (head)
RPUSH   colors   yellow            # push right (tail)
LLEN    colors
LRANGE  colors   0 -1             # -1 = get all
LINSERT colors   BEFORE blue purple
LREM    colors   1 blue            # remove 1 occurrence
LPOP    colors
RPOP    colors
LPUSHX  colors   red              # push only if key exists

Sets

Unordered, unique members. The set operations (UNION, DIFF, INTER) are among the most useful patterns in Redis — e.g., computing mutual friends, tagging systems, permission sets.

SADD      art      pencil brush canvas
SMEMBERS  art
SREM      art      pencil
SCARD     art
SISMEMBER art      pencil

SUNION    art food
SDIFF     art food
SINTER    art food

# Store set operation results into a new key
SUNIONSTORE  result   art food
SDIFFSTORE   result   art food
SINTERSTORE  result   art food

Sorted Sets

Every member gets a floating-point score. Members are unique; scores can repeat. Perfect for leaderboards, rate limiting, and time-series data (use Unix timestamp as score).

ZADD    players   1 john
ZADD    players   10 ben   20 kim   30 sam   50 tammy
ZRANGE  players   0 -1                   # asc by score
ZRANGE  players   0 -1   'withscores'
ZREVRANGE players 0 -1                   # desc
ZRANK   players   kim                    # rank (0-indexed)
ZCARD   players                          # count
ZCOUNT  players   0 -1                   # count by score
ZRANGEBYSCORE players 0 50
ZRANGEBYSCORE players 0 80 'withscores'

5. Pub/Sub — Database-Agnostic Messaging

Redis Pub/Sub is a fire-and-forget messaging system. It's database-agnostic — a subscriber on redis db 0 can receive messages published from a client connected to a different db. This makes it suitable as a lightweight event bus.

# Subscriber
SUBSCRIBE    general
PSUBSCRIBE   p*          # pattern — anything starting with "p"
PSUBSCRIBE   h?llo       # matches "hello", "hallo", etc.
UNSUBSCRIBE  general
UNSUBSCRIBE              # unsubscribe from all
PUNSUBSCRIBE             # unsubscribe all pattern subs

# Publisher
PUBLISH  general  "How are you?"

# Introspection
PUBSUB   channels *

6. Transactions with MULTI/EXEC

Redis transactions let you queue multiple commands and execute them atomically. Useful when inserting values that depend on each other — e.g., updating a user's score and simultaneously recording the event.

# Queue commands atomically
MULTI
  SADD   people   joe fred suzanne
  SET    life     fun
  SET    day      bright
EXEC

# Discard a queued transaction
MULTI
  SADD   animals   horse dog
  SET    age       5
DISCARD

7. HyperLogLog — Probabilistic Counting at Scale

Available since Redis 2.8.9. HyperLogLog is designed for one thing: counting unique elements in a massive dataset with minimal memory. Google and Facebook use this pattern. It gives ~98% accuracy (±2% error) and uses at most 12 KB of memory, regardless of how many unique items you've tracked.

The classic use case: counting unique daily active users or signups. Storing 20k raw user IDs per hour × 24 hours would be ridiculous; HyperLogLog keeps that footprint trivially small.

# Timestamp = Redis key; values = unique user IDs
PFADD   signups:102514   jesse@mail.com
PFADD   signups:102514   tom@mail.com
PFADD   signups:102515   jane@mail.com
PFADD   signups:102516   jenny@mail.com

PFCOUNT  signups:102514
PFCOUNT  signups:102515

# Merge multiple HLLs into one key
PFMERGE  total:weekly   signups:102514   signups:102515   signups:102516
PFCOUNT  total:weekly

8. Client Quickstart (PHP & Python)

PHP — Predis

Install via Composer: "predis/predis": "^1.0.0". Then composer update.

<?php
require '../vendor/autoload.php';

$redis = new Predis\Client([
    'scheme' => 'tcp',
    'host'   => 'localhost',
    'port'   => 6379,
]);

$exists = $redis->exists('age');
if (!$exists) {
    $redis->set('age', 1);
} else {
    $redis->incr('age');
}

Python — redis-py

# pip install redis
import redis

r = redis.Redis(host='localhost', port=6379)

r.set('numerical', 50)
r.hset('animals', 'mammals', 'dog')
r.hset('animals', 'mammals', 'pig')

r.hmset('humans', {
    'ted': 20,
    'jane': 40
})

r.hgetall('animals')
r.hgetall('humans')

9. Production Checklist

Security — Enable AUTH

By default Redis has no password. In production, edit /etc/redis/redis.conf and uncomment requirepass. Restart the server, then authenticate:

# In redis-cli
AUTH   your_secret_password
SET    name 5    # → returns OK after auth

Database Selection

Redis ships with 16 logical databases (0–15) by default. Use SELECT to switch:

SELECT  0   # default
SELECT  3   # switch to db 3

Monitoring

redis-cli monitor   # live command stream — use sparingly in prod
redis-server --version
sudo service redis-server start
sudo service redis-server stop

Connection Commands Reference

AUTH     password
ECHO     message
PING                # → PONG
SELECT   index
QUIT