Redis를 활용한 실시간 리더보드 구현: 100만 동시 사용자 지원하기

# Python 예시 (redis-py 사용)
import redis

r = redis.Redis(host='localhost', port=6379, db=0)

def update_score(user_id: str, score: int, leaderboard: str = "global"):
    """점수 등록 - 기존 점수보다 높을 때만 업데이트"""
    key = f"leaderboard:{leaderboard}"
    current = r.zscore(key, user_id)

    if current is None or score > current:
        r.zadd(key, {user_id: score})
        return True
    return False

# 사용 예
update_score("user:123", 15000, "weekly")

def get_top_players(leaderboard: str, limit: int = 100):
    """상위 N명 조회"""
    key = f"leaderboard:{leaderboard}"
    # ZREVRANGE: 높은 점수부터 내림차순
    results = r.zrevrange(key, 0, limit - 1, withscores=True)
    return [{"user_id": uid.decode(), "score": int(score), "rank": idx + 1}
            for idx, (uid, score) in enumerate(results)]

def get_user_rank(user_id: str, leaderboard: str = "global"):
    """특정 유저 순위 조회"""
    key = f"leaderboard:{leaderboard}"
    rank = r.zrevrank(key, user_id)  # 0-indexed
    score = r.zscore(key, user_id)
    return {"rank": rank + 1 if rank is not None else None, "score": score}

def get_nearby_players(user_id: str, leaderboard: str, range_size: int = 5):
    """내 주변 순위 조회 (위아래 5명씩)"""
    key = f"leaderboard:{leaderboard}"
    rank = r.zrevrank(key, user_id)
    if rank is None:
        return []

    start = max(0, rank - range_size)
    end = rank + range_size
    results = r.zrevrange(key, start, end, withscores=True)
    return [{"user_id": uid.decode(), "score": int(score), "rank": start + idx + 1}
            for idx, (uid, score) in enumerate(results)]

def batch_update_scores(updates: list):
    """배치 점수 업데이트 - [{user_id, score}, ...]"""
    pipe = r.pipeline()
    for item in updates:
        pipe.zadd("leaderboard:global", {item["user_id"]: item["score"]})
    pipe.execute()  # 한 번의 네트워크 요청으로 처리

-- update_if_higher.lua
local key = KEYS[1]
local user_id = ARGV[1]
local new_score = tonumber(ARGV[2])

local current = redis.call('ZSCORE', key, user_id)
if not current or new_score > tonumber(current) then
    redis.call('ZADD', key, new_score, user_id)
    return 1
end
return 0

# Python에서 Lua 스크립트 실행
update_script = r.register_script(open('update_if_higher.lua').read())
result = update_script(keys=['leaderboard:global'], args=['user:123', 15000])

# redis-cluster.conf
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000

# 샤딩 키 설계
# leaderboard:{weekly}:shard_0
# leaderboard:{weekly}:shard_1
# Hash Tag로 같은 노드에 배치

def create_weekly_leaderboard():
    """주간 리더보드 생성 (7일 후 자동 삭제)"""
    week_num = datetime.now().isocalendar()[1]
    key = f"leaderboard:weekly:{week_num}"
    r.expire(key, 60 * 60 * 24 * 7)  # 7일 TTL

def get_friends_ranking(user_id: str):
    """친구들 사이에서의 랭킹"""
    # 친구 목록 조회 (Set 자료구조)
    friends = r.smembers(f"friends:{user_id}")
    friends.add(user_id.encode())  # 자신도 포함

    # Pipeline으로 모든 친구 점수 조회
    pipe = r.pipeline()
    for friend in friends:
        pipe.zscore("leaderboard:global", friend)
    scores = pipe.execute()

    # 점수로 정렬하여 랭킹 생성
    friend_scores = [(f.decode(), s) for f, s in zip(friends, scores) if s]
    friend_scores.sort(key=lambda x: x[1], reverse=True)
    return [{"user_id": uid, "score": int(s), "rank": i + 1}
            for i, (uid, s) in enumerate(friend_scores)]

# Prometheus 메트릭 수집
from prometheus_client import Histogram

leaderboard_latency = Histogram(
    'leaderboard_operation_seconds',
    'Leaderboard operation latency',
    ['operation']
)

@leaderboard_latency.labels('get_rank').time()
def get_user_rank_monitored(user_id):
    return get_user_rank(user_id)