Redis: Cache ও Rate Limit

docker run -d --name redis -p 6379:6379 redis:7-alpine
uv add redis

# core/redis.py
from redis.asyncio import Redis
from app.core.config import get_settings

redis = Redis.from_url(get_settings().redis_url, decode_responses=True)

docker exec -it redis redis-cli
127.0.0.1:6379> SET greeting "হ্যালো" EX 60
OK
127.0.0.1:6379> GET greeting
"হ্যালো"
127.0.0.1:6379> TTL greeting
(integer) 54

# Counter: পেজ কতবার দেখা হলো
await redis.incr("views:note:42")

# Sorted set: leaderboard
await redis.zadd("leaderboard:october", {"rahim": 1250, "nusrat": 1890, "karim": 990})
top3 = await redis.zrevrange("leaderboard:october", 0, 2, withscores=True)

# Set: আজ কে কে এসেছে
await redis.sadd("active:2026-10-29", user_id)
count = await redis.scard("active:2026-10-29")

# Geo: ২ km এর মধ্যে rider
await redis.geoadd("riders", (90.4125, 23.8103, "rider:7"))
nearby = await redis.geosearch("riders", longitude=90.41, latitude=23.81, radius=2, unit="km")

# core/cache.py
import json
import random
from collections.abc import Awaitable, Callable
from typing import TypeVar
from pydantic import BaseModel, TypeAdapter

T = TypeVar("T")


async def cached(key: str, ttl: int, loader: Callable[[], Awaitable[T]], adapter: TypeAdapter[T]) -> T:
    raw = await redis.get(key)
    if raw is not None:
        return adapter.validate_json(raw)                   # hit
    value = await loader()                                   # miss → database
    jitter = random.randint(0, ttl // 10)                    # সব key একসাথে শেষ না হোক
    await redis.set(key, adapter.dump_json(value), ex=ttl + jitter)
    return value

# services/note_service.py
STATS_ADAPTER = TypeAdapter(NoteStats)

async def stats(self, user_id: int) -> NoteStats:
    return await cached(
        key=f"notes:stats:v1:{user_id}",                    # key তে user id!
        ttl=300,
        loader=lambda: self.notes.stats_for_user(user_id),
        adapter=STATS_ADAPTER,
    )

async def create(self, user_id: int, data: NoteCreate) -> Note:
    note = ...                                               # save
    await redis.delete(f"notes:stats:v1:{user_id}")         # পুরনো stats বাতিল
    return note

async def check_rate_limit(key: str, limit: int, window_seconds: int) -> None:
    count = await redis.incr(key)                 # atomic: একসাথে ১০০ request এলেও ঠিক গোনা
    if count == 1:
        await redis.expire(key, window_seconds)   # প্রথমবারে মেয়াদ বসাও
    if count > limit:
        ttl = await redis.ttl(key)
        raise TooManyRequestsError(f"অনেকবার চেষ্টা হয়েছে, {ttl} সেকেন্ড পর আবার চেষ্টা করুন")

@router.post("/login")
async def login(data: LoginIn, request: Request, svc: AuthServiceDep):
    email = data.email.lower()
    await check_rate_limit(f"rl:login:email:{email}", limit=5, window_seconds=900)
    await check_rate_limit(f"rl:login:ip:{client_ip(request)}", limit=50, window_seconds=900)
    return await svc.login(email, data.password)

import secrets
import hashlib

async def send_otp(phone: str) -> None:
    await check_rate_limit(f"rl:otp:{phone}", limit=3, window_seconds=600)   # ১০ মিনিটে ৩টা
    code = f"{secrets.randbelow(1_000_000):06d}"                             # নিরাপদ random
    digest = hashlib.sha256(code.encode()).hexdigest()
    await redis.set(f"otp:{phone}", digest, ex=180)                           # ৩ মিনিট
    await redis.delete(f"otp:tries:{phone}")
    await sms.send(phone, f"আপনার কোড {code}। কাউকে বলবেন না।")


async def verify_otp(phone: str, code: str) -> bool:
    tries = await redis.incr(f"otp:tries:{phone}")
    await redis.expire(f"otp:tries:{phone}", 180)
    if tries > 5:
        raise TooManyRequestsError("অনেকবার ভুল হয়েছে, নতুন কোড নিন")
    stored = await redis.get(f"otp:{phone}")
    ok = stored is not None and secrets.compare_digest(stored, hashlib.sha256(code.encode()).hexdigest())
    if ok:
        await redis.delete(f"otp:{phone}", f"otp:tries:{phone}")             # একবারই ব্যবহার
    return ok

import uuid

async def with_lock(name: str, ttl: int = 30):
    token = uuid.uuid4().hex
    acquired = await redis.set(f"lock:{name}", token, nx=True, ex=ttl)   # না থাকলে তবেই বসাও
    if not acquired:
        return None
    return token

async def release(name: str, token: str) -> None:
    # শুধু নিজের lock খুলবো (Lua script এ check আর delete একসাথে, atomic)
    script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"
    await redis.eval(script, 1, f"lock:{name}", token)