ElastiCache: Redis vs Memcached

# Create a Redis cluster mode disabled (single shard, 2 replicas)
aws elasticache create-replication-group \
  --replication-group-id my-redis-cluster \
  --replication-group-description "Production Redis cache" \
  --engine redis \
  --engine-version 7.1 \
  --cache-node-type cache.r7g.large \
  --num-cache-clusters 3 \
  --multi-az-enabled \
  --automatic-failover-enabled \
  --cache-subnet-group-name my-cache-subnet-group \
  --security-group-ids sg-0123456789abcdef0 \
  --at-rest-encryption-enabled \
  --transit-encryption-enabled \
  --auth-token "YourStr0ngRedisP@ssword" \
  --snapshot-retention-limit 7 \
  --snapshot-window "03:00-04:00" \
  --preferred-maintenance-window "sun:05:00-sun:06:00"

# Create a Redis cluster mode enabled (3 shards, 1 replica each)
aws elasticache create-replication-group \
  --replication-group-id my-redis-sharded \
  --replication-group-description "Sharded Redis cache" \
  --engine redis \
  --engine-version 7.1 \
  --cache-node-type cache.r7g.large \
  --num-node-groups 3 \
  --replicas-per-node-group 1 \
  --multi-az-enabled \
  --automatic-failover-enabled \
  --cache-subnet-group-name my-cache-subnet-group \
  --security-group-ids sg-0123456789abcdef0 \
  --at-rest-encryption-enabled \
  --transit-encryption-enabled

# Create an ElastiCache Serverless cache
aws elasticache create-serverless-cache \
  --serverless-cache-name my-serverless-redis \
  --engine redis \
  --cache-usage-limits '{
    "DataStorage": {"Maximum": 10, "Unit": "GB"},
    "ECPUPerSecond": {"Maximum": 15000}
  }' \
  --subnet-ids subnet-abc123 subnet-def456 \
  --security-group-ids sg-0123456789abcdef0

import Redis from "ioredis";
import { DynamoDBClient, GetItemCommand } from "@aws-sdk/client-dynamodb";

const redis = new Redis({
  host: "my-redis-cluster.xxxxx.use1.cache.amazonaws.com",
  port: 6379,
  tls: {},  // Enable TLS for in-transit encryption
});

const dynamodb = new DynamoDBClient({ region: "us-east-1" });

// Lazy loading (cache-aside) pattern
async function getProduct(productId: string) {
  const cacheKey = `product:${productId}`;

  // 1. Check cache first
  const cached = await redis.get(cacheKey);
  if (cached) {
    console.log("Cache HIT:", productId);
    return JSON.parse(cached);
  }

  // 2. Cache miss - read from database
  console.log("Cache MISS:", productId);
  const result = await dynamodb.send(new GetItemCommand({
    TableName: "Products",
    Key: { productId: { S: productId } },
  }));

  if (!result.Item) return null;

  const product = {
    productId: result.Item.productId.S,
    name: result.Item.name.S,
    price: parseFloat(result.Item.price.N!),
    category: result.Item.category.S,
  };

  // 3. Write to cache with TTL (5 minutes)
  await redis.setex(cacheKey, 300, JSON.stringify(product));

  return product;
}

import Redis from "ioredis";
import crypto from "crypto";

const redis = new Redis({
  host: "my-redis-cluster.xxxxx.use1.cache.amazonaws.com",
  port: 6379,
  tls: {},
});

interface Session {
  userId: string;
  email: string;
  role: string;
  loginTime: string;
  lastActivity: string;
  cart?: Array<{ productId: string; quantity: number }>;
}

const SESSION_TTL = 1800; // 30 minutes

// Create a new session
async function createSession(userData: Omit<Session, "loginTime" | "lastActivity">): Promise<string> {
  const sessionId = crypto.randomUUID();
  const session: Session = {
    ...userData,
    loginTime: new Date().toISOString(),
    lastActivity: new Date().toISOString(),
  };

  // Use Redis hash for structured session data
  await redis.hmset(`session:${sessionId}`, {
    userId: session.userId,
    email: session.email,
    role: session.role,
    loginTime: session.loginTime,
    lastActivity: session.lastActivity,
    cart: JSON.stringify(session.cart || []),
  });

  // Set TTL - session expires after 30 minutes of inactivity
  await redis.expire(`session:${sessionId}`, SESSION_TTL);

  return sessionId;
}

// Retrieve and refresh a session
async function getSession(sessionId: string): Promise<Session | null> {
  const data = await redis.hgetall(`session:${sessionId}`);

  if (!data || Object.keys(data).length === 0) {
    return null; // Session expired or does not exist
  }

  // Refresh TTL on every access (sliding expiration)
  await redis.expire(`session:${sessionId}`, SESSION_TTL);

  // Update last activity
  await redis.hset(`session:${sessionId}`, "lastActivity", new Date().toISOString());

  return {
    userId: data.userId,
    email: data.email,
    role: data.role,
    loginTime: data.loginTime,
    lastActivity: data.lastActivity,
    cart: data.cart ? JSON.parse(data.cart) : [],
  };
}

// Destroy a session (logout)
async function destroySession(sessionId: string): Promise<void> {
  await redis.del(`session:${sessionId}`);
}

import Redis from "ioredis";
const redis = new Redis({ host: "my-redis.cache.amazonaws.com", port: 6379, tls: {} });

// --- Leaderboard with Sorted Sets ---
async function updateLeaderboard(userId: string, score: number) {
  await redis.zadd("leaderboard:daily", score, userId);
}

async function getTopPlayers(count: number = 10) {
  // ZREVRANGE returns highest scores first
  return redis.zrevrange("leaderboard:daily", 0, count - 1, "WITHSCORES");
}

async function getPlayerRank(userId: string) {
  // ZREVRANK returns 0-based rank (0 = highest score)
  const rank = await redis.zrevrank("leaderboard:daily", userId);
  return rank !== null ? rank + 1 : null;
}

// --- Rate Limiting with Sliding Window ---
async function checkRateLimit(userId: string, maxRequests: number, windowSeconds: number): Promise<boolean> {
  const key = `ratelimit:${userId}`;
  const now = Date.now();
  const windowStart = now - (windowSeconds * 1000);

  // Use a sorted set with timestamps as scores
  const pipeline = redis.pipeline();
  pipeline.zremrangebyscore(key, 0, windowStart);  // Remove old entries
  pipeline.zadd(key, now, `${now}-${Math.random()}`);  // Add current request
  pipeline.zcard(key);  // Count requests in window
  pipeline.expire(key, windowSeconds);  // Set TTL for cleanup

  const results = await pipeline.exec();
  const requestCount = results?.[2]?.[1] as number;

  return requestCount <= maxRequests;
}

// --- Distributed Lock ---
async function acquireLock(lockName: string, ttlMs: number): Promise<string | null> {
  const lockId = crypto.randomUUID();
  const result = await redis.set(
    `lock:${lockName}`,
    lockId,
    "PX", ttlMs,  // Expire in milliseconds
    "NX"           // Only set if not exists
  );
  return result === "OK" ? lockId : null;
}

async function releaseLock(lockName: string, lockId: string): Promise<boolean> {
  // Lua script ensures atomic check-and-delete
  const script = `
    if redis.call("GET", KEYS[1]) == ARGV[1] then
      return redis.call("DEL", KEYS[1])
    else
      return 0
    end
  `;
  const result = await redis.eval(script, 1, `lock:${lockName}`, lockId);
  return result === 1;
}

# Test failover behavior
aws elasticache test-failover \
  --replication-group-id my-redis-cluster \
  --node-group-id 0001

# View replication group details
aws elasticache describe-replication-groups \
  --replication-group-id my-redis-cluster \
  --query 'ReplicationGroups[0].{
    Status: Status,
    ClusterEnabled: ClusterEnabled,
    MultiAZ: MultiAZ,
    NodeGroups: NodeGroups[].{
      NodeGroupId: NodeGroupId,
      Status: Status,
      Primary: PrimaryEndpoint.Address,
      Reader: ReaderEndpoint.Address,
      Members: NodeGroupMembers[].{
        CacheClusterId: CacheClusterId,
        CurrentRole: CurrentRole,
        PreferredAZ: PreferredAvailabilityZone
      }
    }
  }'

# Set up CloudWatch alarms for critical ElastiCache metrics
aws cloudwatch put-metric-alarm \
  --alarm-name "redis-high-memory" \
  --namespace "AWS/ElastiCache" \
  --metric-name "DatabaseMemoryUsagePercentage" \
  --dimensions Name=CacheClusterId,Value=my-redis-cluster-001 \
  --statistic Average \
  --period 300 \
  --evaluation-periods 3 \
  --threshold 80 \
  --comparison-operator GreaterThanThreshold \
  --alarm-actions "arn:aws:sns:us-east-1:123456789012:ops-alerts"

aws cloudwatch put-metric-alarm \
  --alarm-name "redis-evictions" \
  --namespace "AWS/ElastiCache" \
  --metric-name "Evictions" \
  --dimensions Name=CacheClusterId,Value=my-redis-cluster-001 \
  --statistic Sum \
  --period 300 \
  --evaluation-periods 1 \
  --threshold 100 \
  --comparison-operator GreaterThanThreshold \
  --alarm-actions "arn:aws:sns:us-east-1:123456789012:ops-alerts"

# Check Redis SLOWLOG for slow commands
redis-cli -h my-redis.cache.amazonaws.com --tls SLOWLOG GET 10

# Create a Redis user with RBAC
aws elasticache create-user \
  --user-id app-readonly \
  --user-name app-readonly \
  --engine redis \
  --access-string "on ~product:* ~cache:* +get +mget +hgetall +smembers -@all" \
  --passwords "ReadOnlyP@ssword123"

aws elasticache create-user \
  --user-id app-readwrite \
  --user-name app-readwrite \
  --engine redis \
  --access-string "on ~* +@all -@dangerous" \
  --passwords "ReadWriteP@ssword123"

# Create a user group and associate it with a cluster
aws elasticache create-user-group \
  --user-group-id my-app-users \
  --engine redis \
  --user-ids default app-readonly app-readwrite

aws elasticache modify-replication-group \
  --replication-group-id my-redis-cluster \
  --user-group-ids-to-add my-app-users