Redis and Memcached — Distributed Caching Reference

1
2
3
4
5
6
7
8
9
10

// Cache-aside, the default pattern
value = cache.get(key)
if value is null:
    value = database.load(key)      // authoritative source
    cache.set(key, value, ttl)      // absolute expiry, never infinite
return value

// On write: update the database first, then invalidate the key
database.save(entity)
cache.delete(key)                    // delete, do not update: simpler and safer

1
2
3
4
5
6
7

// Same cache-aside shape, different client
// Memcached: multi-get is the idiom that makes it competitive
var values = memcached.Get(new[] { "user:1", "user:2", "user:3" });
// Redis: one round trip with a pipeline does the same job
var batch = db.CreateBatch();
var tasks = ids.Select(id => batch.StringGetAsync($"user:{id}")).ToArray();
batch.Execute();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

builder.Services.AddSingleton<IConnectionMultiplexer>(_ =>
    ConnectionMultiplexer.Connect(new ConfigurationOptions
    {
        EndPoints = { "redis:6379" },
        AbortOnConnectFail = false,        // survive a cold start
        ConnectRetry = 3,
        ConnectTimeout = 5000,
        SyncTimeout = 2000,
        Ssl = true,
        DefaultDatabase = 0
    }));

// In the repository
public sealed class UserCache(IConnectionMultiplexer mux)
{
    private readonly IDatabase _db = mux.GetDatabase();

    public Task<string?> GetAsync(Guid id) => _db.StringGetAsync($"user:v1:{id}");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import Redis from 'ioredis';

export const redis = new Redis(process.env.REDIS_URL!, {
  maxRetriesPerRequest: 2,
  enableReadyCheck: true,
  retryStrategy: (times) => Math.min(times * 200, 2000)
});

redis.on('error', (err) => logger.error({ err }, 'redis error'));   // mandatory

export async function cached<T>(key: string, ttl: number, load: () => Promise<T>): Promise<T> {
  const hit = await redis.get(key);
  if (hit) { return JSON.parse(hit) as T; }
  const value = await load();
  await redis.set(key, JSON.stringify(value), 'EX', ttl);
  return value;
}

1
2
3
4
5
6
7
8

app:user:v1:8f14e45f          -> JSON blob of a user
app:user:v1:8f14e45f:roles    -> a separate, smaller value
app:catalog:v2:category:12    -> a list, version bumped when the DTO changed
app:lock:invoice:7781         -> a lock key, short TTL

// Group invalidation without SCAN in the hot path
app:user:v1:{id}              // delete one key on write
app:catalog:v2:{category}     // bump v2 -> v3 to invalidate the whole namespace

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Single-flight with a lock and a short TTL
public async Task<Catalog> GetCatalogAsync(int id, CancellationToken ct)
{
    var key = $"app:catalog:v2:{id}";
    var hit = await _db.StringGetAsync(key);
    if (hit.HasValue) { return JsonSerializer.Deserialize<Catalog>(hit!)!; }

    var lockKey = $"app:lock:catalog:{id}";
    var token = Guid.NewGuid().ToString();
    if (await _db.LockTakeAsync(lockKey, token, TimeSpan.FromSeconds(10)))
    {
        try
        {
            var value = await _source.LoadAsync(id, ct);          // authoritative
            await _db.StringSetAsync(key, JsonSerializer.Serialize(value), TimeSpan.FromMinutes(5));
            return value;
        }
        finally { await _db.LockReleaseAsync(lockKey, token); }
    }

    await Task.Delay(50, ct);                                     // someone else is loading
    return await GetCatalogAsync(id, ct);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 1. Delete on write (simplest, safest)
await _repo.SaveAsync(user, ct);
await _cache.KeyDeleteAsync($"app:user:v1:{user.Id}");

// 2. Version segment: bump the prefix, old keys expire on their own
//    app:catalog:v2:*  ->  app:catalog:v3:*   (no mass delete needed)

// 3. Pub/sub for multi-instance invalidation
await _sub.SubscribeAsync("cache:invalidate", (_, msg) =>
    _cache.KeyDelete(msg.ToString()));

// 4. Write-through: cache and store in the same use case
await _repo.SaveAsync(user, ct);
await _cache.StringSetAsync(key, JsonSerializer.Serialize(user), TimeSpan.FromMinutes(10));

1
2
3
4
5
6
7
8
9
10
11
12
13

// Counter with atomic increment
await db.StringIncrementAsync($"app:view:v1:{articleId}");

// Leaderboard
await db.SortedSetIncrementAsync("app:scores:weekly", playerId, points);
var top = await db.SortedSetRangeByRankWithScoresAsync("app:scores:weekly", 0, 9, Order.Descending);

// Deduplication / membership
await db.SetAddAsync("app:seen:2025-05-12", userId);
var unique = await db.SetLengthAsync("app:seen:2025-05-12");

// Hash for a partial update without rewriting the blob
await db.HashSetAsync($"app:session:v1:{sid}", [new("lastSeen", now), new("route", path)]);

1
2
3
4
5
6
7
8
9
10
11
12
13

// Fixed-window rate limiter: 100 requests per minute per API key
public async Task<bool> AllowAsync(string apiKey)
{
    var key = $"app:rl:v1:{apiKey}:{DateTime.UtcNow:yyyyMMddHHmm}";
    var count = await _db.StringIncrementAsync(key);
    if (count == 1) { await _db.KeyExpireAsync(key, TimeSpan.FromMinutes(2)); }
    return count <= 100;
}

// Idempotency key for a payment endpoint
var claimed = await _db.StringSetAsync($"app:idem:v1:{requestId}", "in-flight",
    TimeSpan.FromMinutes(10), When.NotExists);
if (!claimed) { return Results.Conflict("Duplicate request"); }

1
2
3
4
5
6
7
8
9
10
11

// One round trip for many objects: the pattern Memcached is built around
var keys = new[] { "app:user:v1:1", "app:user:v1:2", "app:user:v1:3" };
var results = client.Get(keys);            // IDictionary<string, object>

// CAS when two writers may collide
var item = client.Get("app:config:v1");
if (item != null && client.TryGet("app:config:v1", out var current))
{
    current.Cas(++item.Cas);               // store only if nobody changed it
    client.Store(StoreMode.Replace, "app:config:v1", current);
}

1
2
3
4
5
6
7
8
9
10
11

# redis.conf essentials
maxmemory 2gb
maxmemory-policy allkeys-lru        # evict keys, never fail writes
save 900 1                          # snapshot policy; or AOF for durability
appendonly no                       # AOF costs IO; enable only if you need it

# What to watch, in order of usefulness
INFO stats        -> keyspace_hits, keyspace_misses, evicted_keys
INFO memory       -> used_memory_peak, mem_fragmentation_ratio
slowlog get 10    -> commands above slowlog-log-slower-than
latency monitor   -> spikes correlated with application deploys

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// The shape that survives review
public sealed class CachedCatalogService(
    ICatalogService inner, IDistributedCache cache, ILogger<CachedCatalogService> log)
{
    public async Task<Catalog?> GetAsync(int id, CancellationToken ct)
    {
        var key = $"app:catalog:v2:{id}";
        try
        {
            var hit = await cache.GetStringAsync(key, ct);
            if (hit is not null) { return JsonSerializer.Deserialize<Catalog>(hit); }
        }
        catch (Exception ex) { log.LogWarning(ex, "Cache read failed for {Key}", key); }

        var value = await inner.GetAsync(id, ct);          // always works
        if (value is not null)
        {
            try { await cache.SetStringAsync(key, JsonSerializer.Serialize(value), ct); }
            catch (Exception ex) { log.LogWarning(ex, "Cache write failed for {Key}", key); }
        }
        return value;
    }
}