ElastiCache & Caching Strategies

1import { createClient } from 'redis';
2const redis = createClient({ url: process.env.REDIS_URL });
3
4async function getUser(userId) {
5  const cacheKey = `user:${userId}`;
6
7  // 1. Check cache
8  const cached = await redis.get(cacheKey);
9  if (cached) {
10    return JSON.parse(cached);  // cache HIT — database not touched
11  }
12
13  // 2. Cache MISS — fetch from database
14  const user = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
15
16  // 3. Populate cache with TTL
17  await redis.setEx(cacheKey, 300, JSON.stringify(user)); // expires in 5 min
18
19  return user;
20}

1async function updateUser(userId, data) {
2  // Write to DB first
3  await db.query('UPDATE users SET ... WHERE id = $1', [userId]);
4
5  // Immediately update cache
6  const cacheKey = `user:${userId}`;
7  await redis.setEx(cacheKey, 3600, JSON.stringify(data));
8}

1async function updateUserWriteBehind(userId, data) {
2  const cacheKey = `user:${userId}`;
3
4  // Instant cache write — return immediately
5  await redis.setEx(cacheKey, 3600, JSON.stringify(data));
6
7  // Queue async DB write (processed by a background worker)
8  await redis.lPush('db:write:queue', JSON.stringify({ userId, data, ts: Date.now() }));
9}

1// TTL strategies
2await redis.setEx('product:123', 60,    JSON.stringify(product)); // 1 min — frequently changing
3await redis.setEx('config:flags', 3600, JSON.stringify(flags));   // 1 hour — rarely changing
4await redis.setEx('user:session', 86400, JSON.stringify(session)); // 1 day — session
5
6// Always combine TTL with Lazy Loading
7// TTL prevents stale data from living forever

1async function deleteProduct(productId) {
2  await db.query('DELETE FROM products WHERE id = $1', [productId]);
3
4  // Explicitly invalidate all related cache keys
5  await redis.del(`product:${productId}`);
6  await redis.del('products:list:all');
7  await redis.del('products:list:featured');
8}

1await redis.set('counter', 0);
2await redis.incr('counter');               // atomic increment → 1
3await redis.incrBy('counter', 5);          // → 6
4await redis.setEx('session:abc', 3600, token); // with TTL

1// Store a user object field-by-field (memory efficient)
2await redis.hSet('user:123', {
3  name: 'Alice',
4  email: 'alice@example.com',
5  tier: 'premium',
6});
7
8const name = await redis.hGet('user:123', 'name');
9const user = await redis.hGetAll('user:123');  // returns full object

1// Activity feed (newest first)
2await redis.lPush('feed:usr_01', JSON.stringify({ action: 'liked', ts: Date.now() }));
3await redis.lTrim('feed:usr_01', 0, 99); // keep only 100 most recent items
4
5const feed = await redis.lRange('feed:usr_01', 0, 19); // get first 20
6
7// Simple queue (FIFO)
8await redis.rPush('job:queue', JSON.stringify(job));       // enqueue
9const job = await redis.lPop('job:queue');                  // dequeue

1// Game leaderboard
2await redis.zAdd('leaderboard:global', [
3  { score: 9850, value: 'player:alice' },
4  { score: 8200, value: 'player:bob' },
5  { score: 7500, value: 'player:carol' },
6]);
7
8// Update a player's score
9await redis.zIncrBy('leaderboard:global', 150, 'player:bob'); // bob → 8350
10
11// Get top 10 (highest scores first)
12const top10 = await redis.zRangeWithScores('leaderboard:global', 0, 9, { REV: true });
13
14// Get a player's rank (0-indexed, 0 = top)
15const rank = await redis.zRevRank('leaderboard:global', 'player:alice');

1// Track unique page visitors (no duplicates)
2await redis.sAdd(`visitors:${today}`, userId);
3const uniqueCount = await redis.sCard(`visitors:${today}`);
4
5// Common friends between two users
6const commonFriends = await redis.sInter('friends:alice', 'friends:bob');
7
8// Check membership O(1)
9const isFollowing = await redis.sIsMember('follows:alice', 'bob');

1// Store session
2const sessionId = crypto.randomUUID();
3await redis.setEx(
4  `session:${sessionId}`,
5  86400,  // 24 hour TTL
6  JSON.stringify({ userId, email, tier, loginAt: Date.now() })
7);
8
9// Read session (any instance)
10const session = JSON.parse(await redis.get(`session:${sessionId}`) ?? 'null');
11if (!session) throw new Error('Session expired');
12
13// Extend session on activity (sliding expiry)
14await redis.expire(`session:${sessionId}`, 86400);

1async function checkRateLimit(userId, limitPerMinute = 100) {
2  const key = `rate:${userId}:${Math.floor(Date.now() / 60000)}`; // per-minute window
3
4  const count = await redis.incr(key);
5  if (count === 1) {
6    await redis.expire(key, 60); // set TTL on first request
7  }
8
9  if (count > limitPerMinute) {
10    throw new Error('Rate limit exceeded'); // return HTTP 429
11  }
12
13  return { remaining: limitPerMinute - count };
14}

1save 900 1      # snapshot if 1 key changed in 900s
2save 300 10     # snapshot if 10 keys changed in 300s
3save 60 10000   # snapshot if 10,000 keys changed in 60s

1# Redis AUTH token (password)
2aws elasticache create-replication-group \
3  --replication-group-id my-redis \
4  --auth-token "MyStrongPassword123!" \
5  --transit-encryption-enabled   # TLS in transit
6  --at-rest-encryption-enabled   # encrypted at rest (KMS)
7
8# IAM auth (Redis 7.0+) — use AWS credentials instead of password
9aws elasticache create-user \
10  --user-id app-user \
11  --user-name app-user \
12  --engine redis \
13  --authentication-type iam