Redis: кэш, TTL и счётчики

docker run -d --rm --name redis-lab -p 127.0.0.1:56391:6379 redis:8.10-alpine
docker exec redis-lab redis-cli INFO server | grep redis_version
docker exec -it redis-lab redis-cli

$ docker exec redis-lab redis-cli INFO server | grep redis_version
redis_version:8.10.2
$ docker exec redis-lab redis-cli PING
PONG

> SET site:title "Demo Booking"
OK
> GET site:title
"Demo Booking"
> SET page:views 10
OK
> INCR page:views
(integer) 11
> INCRBY page:views 5
(integer) 16
> INCR site:title
(error) ERR value is not an integer or out of range
> GET missing:key
(nil)

> HSET service:1 title "Haircut" duration_min 60 price_kzt 8000
(integer) 3
> HGET service:1 price_kzt
"8000"
> HGETALL service:1
1) "title"
2) "Haircut"
3) "duration_min"
4) "60"
5) "price_kzt"
6) "8000"
> HINCRBY service:1 price_kzt 500
(integer) 8500
> SADD service:1:masters "aigerim" "dana" "aigerim"
(integer) 2
> SCARD service:1:masters
(integer) 2
> SISMEMBER service:1:masters "dana"
(integer) 1
> SMEMBERS service:1:masters
1) "aigerim"
2) "dana"
> RPUSH leads:recent "lead-101" "lead-102" "lead-103"
(integer) 3
> LRANGE leads:recent 0 -1
1) "lead-101"
2) "lead-102"
3) "lead-103"
> TYPE service:1
hash
> GET service:1
(error) WRONGTYPE Operation against a key holding the wrong kind of value

> SET otp:demo-user "4821" EX 60
OK
> TTL otp:demo-user
(integer) 60
> TTL site:title
(integer) -1
> TTL no:such:key
(integer) -2
> EXPIRE site:title 2
(integer) 1
# ...3 seconds later
> GET site:title
(nil)
> TTL site:title
(integer) -2
> SET visits:today 1 EX 100
OK
> INCR visits:today
(integer) 2
> TTL visits:today
(integer) 99
> SET visits:today 5
OK
> TTL visits:today
(integer) -1
> SET lock:report 1 NX EX 30
OK
> SET lock:report 1 NX EX 30
(nil)
> CONFIG GET maxmemory
1) "maxmemory"
2) "0"
> CONFIG GET maxmemory-policy
1) "maxmemory-policy"
2) "noeviction"

mkdir redis-cache && cd redis-cache
npm init -y
npm pkg set type=module
npm install redis@6.3.0

import { createClient } from "redis";

export const redis = createClient({
  url: process.env.REDIS_URL ?? "redis://localhost:56391",
  // while reconnecting, fail a waiting command after 500 ms instead of the default 5 s
  commandOptions: { timeout: 500 },
});
redis.on("error", (err) => console.error("redis error:", err.code ?? err.name));
await redis.connect();

// Stand-in for a slow database: in a real project this is SQL or an external API
const services = [
  { id: 1, title: "Haircut", priceKzt: 8000 },
  { id: 2, title: "Manicure", priceKzt: 10000 },
  { id: 3, title: "Massage", priceKzt: 15000 },
];
export const stats = { dbCalls: 0 };
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

export async function loadServicesFromDb() {
  stats.dbCalls++;
  await sleep(300); // a heavy query
  return structuredClone(services);
}

export async function updatePriceInDb(id, priceKzt) {
  await sleep(20);
  const service = services.find((s) => s.id === id);
  if (!service) throw new Error(`Service ${id} not found`);
  service.priceKzt = priceKzt;
}

import { redis } from "./redis.js";

// Cache-aside: try the cache; on a miss load from the source and store with a TTL
export async function cached(key, ttlSeconds, load) {
  let redisOk = true;
  try {
    const hit = await redis.get(key);
    if (hit !== null) return { data: JSON.parse(hit), source: "cache" };
  } catch (err) {
    redisOk = false; // Redis is unavailable: serve from the source, don't fail the request
    console.warn(`cache read skipped: ${err.constructor.name}`);
  }
  const data = await load();
  if (redisOk) {
    await redis
      .set(key, JSON.stringify(data), { expiration: { type: "EX", value: ttlSeconds } })
      .catch((err) => console.warn(`cache write skipped: ${err.constructor.name}`));
  }
  return { data, source: "db" };
}

export async function invalidate(...keys) {
  await redis.del(keys);
}

import { cached, invalidate } from "./cache.js";
import { loadServicesFromDb, updatePriceInDb } from "./db.js";

const SERVICES_KEY = "cache:services:v1";
const SERVICES_TTL = 300; // 5 minutes: the upper bound of staleness if invalidation is missed

export function getServices() {
  return cached(SERVICES_KEY, SERVICES_TTL, loadServicesFromDb);
}

export async function changePrice(id, priceKzt) {
  await updatePriceInDb(id, priceKzt); // 1. write to the source of truth
  await invalidate(SERVICES_KEY); // 2. only then drop the stale copy
}

import { redis } from "./redis.js";
import { getServices, changePrice } from "./catalog.js";
import { stats } from "./db.js";

async function timed(label, fn) {
  const t0 = performance.now();
  const { data, source } = await fn();
  const ms = (performance.now() - t0).toFixed(1);
  console.log(`${label}: ${source} in ${ms} ms, Haircut = ${data[0].priceKzt}`);
}

await redis.del("cache:services:v1");
await timed("1st read", getServices);
await timed("2nd read", getServices);
console.log("TTL:", await redis.ttl("cache:services:v1"));

await changePrice(1, 9000);
console.log("after invalidation exists:", await redis.exists("cache:services:v1"));
await timed("3rd read", getServices);
await timed("4th read", getServices);
console.log("db calls:", stats.dbCalls);

await redis.close();

$ node src/demo-cache.js
1st read: db in 302.5 ms, Haircut = 8000
2nd read: cache in 0.7 ms, Haircut = 8000
TTL: 300
after invalidation exists: 0
3rd read: db in 308.2 ms, Haircut = 9000
4th read: cache in 0.7 ms, Haircut = 9000
db calls: 2

warm: db in 305 ms
redis error: Error
redis error: ECONNREFUSED
redis error: ECONNREFUSED
redis error: ECONNREFUSED
cache read skipped: TimeoutError
redis error: ECONNREFUSED
redis stopped: db in 824 ms

import { redis } from "./redis.js";

// Views per service per day: one hash per day, kept for 8 days
export async function countView(serviceId, day = new Date().toISOString().slice(0, 10)) {
  const key = `stats:views:${day}`;
  const [views] = await redis
    .multi()
    .hIncrBy(key, String(serviceId), 1)
    .expire(key, 8 * 24 * 3600, "NX")
    .exec();
  return views;
}

// Fixed window: at most `limit` requests per `windowSec` seconds for one client
export async function rateLimit(clientId, limit, windowSec) {
  const key = `rl:lead-form:${clientId}`;
  // MULTI/EXEC: INCR and EXPIRE are sent together, the counter can't be left without a TTL
  const [count, , ttl] = await redis
    .multi()
    .incr(key)
    .expire(key, windowSec, "NX") // NX: set the TTL only on the first request of the window
    .ttl(key)
    .exec();
  return { allowed: count <= limit, count, retryAfter: count <= limit ? 0 : ttl };
}

import { redis } from "./redis.js";
import { countView, rateLimit } from "./counters.js";

await redis.del(["rl:lead-form:203.0.113.7", "rl:lead-form:198.51.100.20", "stats:views:2026-10-12"]);

for (const id of [1, 1, 2, 1, 3]) await countView(id, "2026-10-12");
console.log("views:", await redis.hGetAll("stats:views:2026-10-12"));
console.log("views TTL:", await redis.ttl("stats:views:2026-10-12"));

// The lead form: 5 submissions per 60 seconds per IP (addresses from documentation ranges)
for (let i = 1; i <= 7; i++) {
  const r = await rateLimit("203.0.113.7", 5, 60);
  console.log(`request ${i}: ${r.allowed ? "200 OK" : `429, retry after ${r.retryAfter}s`} (count ${r.count})`);
}
const other = await rateLimit("198.51.100.20", 5, 60);
console.log(`another IP: ${other.allowed ? "200 OK" : "429"} (count ${other.count})`);

await redis.close();

$ node src/demo-limits.js
views: { '1': '3', '2': '1', '3': '1' }
views TTL: 691200
request 1: 200 OK (count 1)
request 2: 200 OK (count 2)
request 3: 200 OK (count 3)
request 4: 200 OK (count 4)
request 5: 200 OK (count 5)
request 6: 429, retry after 60s (count 6)
request 7: 429, retry after 60s (count 7)
another IP: 200 OK (count 1)

> TTL rl:lead-form:203.0.113.7
(integer) 60
> HGETALL stats:views:2026-10-12
1) "1"
2) "3"
3) "2"
4) "1"
5) "3"
6) "1"

$ docker exec redis-lab redis-cli --scan --pattern 'rl:*'
rl:lead-form:198.51.100.20
rl:lead-form:203.0.113.7