260720_1720_대용량 선착순 예매 시스템 — Redis + Express 완전 구현 가이드

예시: - RDB 예매 처리 TPS = 100건/초 - 안전 마진 70% 적용 → 스케줄러 입장 처리 = 70명/초 - 스케줄러 주기 = 1초 - 매 tick마다 ZPOPMIN 70명 → active_users에 등록

# active_users는 Hash + TTL 또는 Sorted Set + score(만료시각) # 3분 = 180초 EXPIRE active:user:{uuid} 180

ticket-queue-system/ ├── src/ │ ├── app.ts # Express 앱 진입점 │ ├── server.ts # HTTP 서버 시작 │ ├── config/ │ │ ├── index.ts # 환경변수 로드 │ │ └── redis.ts # Redis 연결 │ ├── routes/ │ │ ├── queue.routes.ts # 대기열 등록 │ │ ├── status.routes.ts # 폴링/상태 조회 │ │ └── booking.routes.ts # 예매 처리 │ ├── services/ │ │ ├── queue.service.ts # 대기열 비즈니스 로직 │ │ ├── entry.service.ts # 입장 처리 │ │ ├── booking.service.ts # 예매 처리 │ │ └── polling.service.ts # 폴링 응답 생성 │ ├── scheduler/ │ │ └── entry.scheduler.ts # 입장 스케줄러 │ ├── redis/ │ │ ├── keys.ts # Redis 키 상수 │ │ └── scripts/ │ │ ├── reserve-seats.lua # 좌석 차감 Lua │ │ └── pop-queue.lua # 대기열 pop Lua │ ├── mq/ │ │ └── publisher.ts # MQ 발행 (선택) │ ├── db/ │ │ └── reservation.repo.ts # RDB 저장 (선택) │ ├── middleware/ │ │ ├── errorHandler.ts │ │ └── rateLimit.ts │ └── types/ │ └── index.ts ├── docker-compose.yml # Redis, PostgreSQL, RabbitMQ ├── package.json ├── tsconfig.json └── .env.example

{ "name": "ticket-queue-system", "version": "1.0.0", "scripts": { "dev": "tsx watch src/server.ts", "build": "tsc", "start": "node dist/server.js", "scheduler": "tsx src/scheduler/entry.scheduler.ts" }, "dependencies": { "express": "^4.21.0", "ioredis": "^5.4.1", "uuid": "^9.0.1", "zod": "^3.23.8", "node-cron": "^3.0.3", "cors": "^2.8.5", "helmet": "^7.1.0", "amqplib": "^0.10.4", "pg": "^8.12.0" }, "devDependencies": { "@types/express": "^4.17.21", "@types/node": "^20.14.0", "@types/uuid": "^9.0.8", "@types/cors": "^2.8.17", "typescript": "^5.5.0", "tsx": "^4.16.0" } }

{ "compilerOptions": { "target": "ES2022", "module": "commonjs", "lib": ["ES2022"], "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "resolveJsonModule": true, "declaration": true }, "include": ["src/**/*"], "exclude": ["node_modules", "dist"] }

version: '3.8' services: redis: image: redis:7-alpine ports: - "6379:6379" command: redis-server --appendonly yes volumes: - redis_data:/data # Redis Cluster (운영 환경) # redis-node-1: # image: redis:7-alpine # command: redis-server --cluster-enabled yes ... postgres: image: postgres:16-alpine environment: POSTGRES_DB: ticket POSTGRES_USER: ticket POSTGRES_PASSWORD: ticket123 ports: - "5432:5432" volumes: - pg_data:/var/lib/postgresql/data rabbitmq: image: rabbitmq:3-management-alpine ports: - "5672:5672" - "15672:15672" volumes: redis_data: pg_data:

# Server PORT=3000 NODE_ENV=development # Redis REDIS_HOST=localhost REDIS_PORT=6379 REDIS_PASSWORD= # Scheduler ENTRY_BATCH_SIZE=70 # 1초당 입장 인원 (RDB TPS * 0.7) ENTRY_CRON=*/1 * * * * * # 1초마다 (node-cron 6필드) ACTIVE_USER_TTL_SEC=180 # 3분 # Event EVENT_ID=ktx-2026-chuseok TOTAL_SEATS=100 # 7시 차次 총 좌석 # MQ (선택) RABBITMQ_URL=amqp://localhost:5672 BOOKING_QUEUE=booking.completed # DB (선택) DATABASE_URL=postgresql://ticket:ticket123@localhost:5432/ticket

import { z } from 'zod'; const envSchema = z.object({ PORT: z.coerce.number().default(3000), NODE_ENV: z.enum(['development', 'production', 'test']).default('development'), REDIS_HOST: z.string().default('localhost'), REDIS_PORT: z.coerce.number().default(6379), REDIS_PASSWORD: z.string().optional(), ENTRY_BATCH_SIZE: z.coerce.number().default(70), ACTIVE_USER_TTL_SEC: z.coerce.number().default(180), EVENT_ID: z.string().default('default-event'), TOTAL_SEATS: z.coerce.number().default(100), RABBITMQ_URL: z.string().optional(), BOOKING_QUEUE: z.string().default('booking.completed'), DATABASE_URL: z.string().optional(), }); const parsed = envSchema.safeParse(process.env); if (!parsed.success) { console.error('환경변수 검증 실패:', parsed.error.flatten()); process.exit(1); } export const config = parsed.data;

import Redis from 'ioredis'; import { config } from './index'; import fs from 'fs'; import path from 'path'; // 단일 인스턴스 (개발) export const redis = new Redis({ host: config.REDIS_HOST, port: config.REDIS_PORT, password: config.REDIS_PASSWORD || undefined, maxRetriesPerRequest: 3, enableReadyCheck: true, lazyConnect: false, }); // Lua 스크립트 SHA 캐시 const scriptsDir = path.join(__dirname, '../redis/scripts'); const scriptCache = new Map<string, string>(); export async function loadLuaScript(name: string): Promise<string> { if (scriptCache.has(name)) { return scriptCache.get(name)!; } const filePath = path.join(scriptsDir, `${name}.lua`); const source = fs.readFileSync(filePath, 'utf-8'); const sha = (await redis.script('LOAD', source)) as string; scriptCache.set(name, sha); return sha; } export async function evalLua( name: string, numKeys: number, ...args: (string | number)[] ): Promise<unknown> { const sha = await loadLuaScript(name); try { return await redis.evalsha(sha, numKeys, ...args); } catch (err: unknown) { // NOSCRIPT: 캐시 미스 시 재로드 if (err instanceof Error && err.message.includes('NOSCRIPT')) { scriptCache.delete(name); const newSha = await loadLuaScript(name); return redis.evalsha(newSha, numKeys, ...args); } throw err; } } redis.on('error', (err) => { console.error('[Redis] 연결 오류:', err.message); }); redis.on('connect', () => { console.log('[Redis] 연결됨'); });

import express from 'express'; import cors from 'cors'; import helmet from 'helmet'; import { queueRouter } from './routes/queue.routes'; import { statusRouter } from './routes/status.routes'; import { bookingRouter } from './routes/booking.routes'; import { errorHandler } from './middleware/errorHandler'; export function createApp() { const app = express(); app.use(helmet()); app.use(cors()); app.use(express.json({ limit: '10kb' })); // Health check (로드밸런서용) app.get('/health', (_req, res) => { res.json({ status: 'ok', timestamp: Date.now() }); }); app.use('/api/queue', queueRouter); app.use('/api/status', statusRouter); app.use('/api/booking', bookingRouter); app.use(errorHandler); return app; }

import { createApp } from './app'; import { config } from './config'; import { redis } from './config/redis'; async function main() { await redis.ping(); console.log('[Redis] PING OK'); const app = createApp(); const server = app.listen(config.PORT, () => { console.log(`[Server] <http://localhost>:${config.PORT}`); }); // Graceful shutdown const shutdown = async (signal: string) => { console.log(`[Server] ${signal} 수신, 종료 중...`); server.close(); await redis.quit(); process.exit(0); }; process.on('SIGTERM', () => shutdown('SIGTERM')); process.on('SIGINT', () => shutdown('SIGINT')); } main().catch((err) => { console.error('[Server] 시작 실패:', err); process.exit(1); });

import { Request, Response, NextFunction } from 'express'; export class AppError extends Error { constructor( public statusCode: number, message: string, public code?: string ) { super(message); this.name = 'AppError'; } } export function errorHandler( err: Error, _req: Request, res: Response, _next: NextFunction ) { if (err instanceof AppError) { return res.status(err.statusCode).json({ success: false, error: { code: err.code, message: err.message }, }); } console.error('[Error]', err); return res.status(500).json({ success: false, error: { code: 'INTERNAL_ERROR', message: '서버 오류가 발생했습니다.' }, }); }

import { Request, Response, NextFunction } from 'express'; import { redis } from '../config/redis'; /** * IP당 초당 N회 제한 (대기열 등록 API용) * 운영에서는 Nginx/ALB 레벨 rate limit 병행 권장 */ export function rateLimit(maxPerSecond: number = 5) { return async (req: Request, res: Response, next: NextFunction) => { const ip = req.ip || 'unknown'; const key = `ratelimit:${ip}:${Math.floor(Date.now() / 1000)}`; const count = await redis.incr(key); if (count === 1) { await redis.expire(key, 2); } if (count > maxPerSecond) { return res.status(429).json({ success: false, error: { code: 'RATE_LIMIT', message: '요청이 너무 많습니다.' }, }); } next(); }; }

export type QueueStatus = 'WAITING' | 'ACTIVE' | 'EXPIRED' | 'NOT_FOUND'; export interface QueueJoinResponse { success: true; data: { token: string; // UUID (클라이언트 식별) eventId: string; joinedAt: number; }; } export interface StatusPollResponse { success: true; data: { status: QueueStatus; rank: number | null; // 대기 중일 때 내 순번 (1-based) totalWaiting: number; // 전체 대기 인원 ahead: number | null; // 내 앞 대기 인원 behind: number | null; // 내 뒤 대기 인원 remainingSeats: number; // 잔여 좌석 nextPollMs: number; // 다음 폴링 권장 간격 (ms) activeExpiresAt: number | null; // ACTIVE일 때 만료 시각 }; } export interface BookingRequest { token: string; seatCount: number; // 예매할 좌석 수 (N장) } export interface BookingResponse { success: true; data: { reservationId: string; seatCount: number; remainingSeats: number; }; }

# 1. 의존성 설치 npm install # 2. 인프라 기동 docker compose up -d # 3. 환경변수 cp .env.example .env # 4. API 서버 npm run dev # 5. 스케줄러 (별도 프로세스) npm run scheduler

{서비스}:{이벤트ID}:{엔티티}:{식별자}

import { config } from '../config'; const PREFIX = 'ticket'; export const keys = { /** Phase 1: 대기열 Sorted Set */ waitingQueue: (eventId: string = config.EVENT_ID) => `${PREFIX}:${eventId}:queue:waiting`, /** Phase 2: Active User Sorted Set (score = expireAt timestamp) */ activeUsers: (eventId: string = config.EVENT_ID) => `${PREFIX}:${eventId}:active:users`, /** Phase 3: 잔여 좌석 */ remainingSeats: (eventId: string = config.EVENT_ID) => `${PREFIX}:${eventId}:seats:remaining`, /** 예매 완료 멱등성 키 (중복 예매 방지) */ bookingDone: (token: string, eventId: string = config.EVENT_ID) => `${PREFIX}:${eventId}:booking:done:${token}`, /** 이벤트 메타 정보 */ eventMeta: (eventId: string = config.EVENT_ID) => `${PREFIX}:${eventId}:meta`, };

Key: ticket:ktx-2026-chuseok:queue:waiting Type: ZSET Member: UUID (사용자 토큰) Score: 접수 시각 (Unix timestamp ms)

# 대기열 등록 (멱등: 같은 UUID면 score만 갱신되지 않고 유지) ZADD ticket:ktx-2026-chuseok:queue:waiting NX 1704067200000 "a1b2c3d4-..." # 내 순번 조회 (0-based → +1 하면 1-based) ZRANK ticket:ktx-2026-chuseok:queue:waiting "a1b2c3d4-..." # 전체 대기 인원 ZCARD ticket:ktx-2026-chuseok:queue:waiting # 앞에서 N명 꺼내기 (스케줄러) ZPOPMIN ticket:ktx-2026-chuseok:queue:waiting 70 # 특정 유저 제거 (취소 기능 시) ZREM ticket:ktx-2026-chuseok:queue:waiting "a1b2c3d4-..."

ZADD key NX score member

사용자 A: score 1704067200000 (7:00:00.000) 사용자 B: score 1704067200001 (7:00:00.001) 사용자 C: score 1704067200002 (7:00:00.002)

Key: ticket:ktx-2026-chuseok:active:users Type: ZSET Member: UUID Score: 만료 시각 (Unix timestamp ms) = now + 180000

# 입장 처리 (스케줄러) ZADD ticket:ktx-2026-chuseok:active:users 1704067380000 "a1b2c3d4-..." # Active 여부 확인 ZSCORE ticket:ktx-2026-chuseok:active:users "a1b2c3d4-..." # 만료된 유저 정리 (score < now) ZREMRANGEBYSCORE ticket:ktx-2026-chuseok:active:users -inf 1704067200000

SET active:user:{uuid} 1 EX 180

Key: ticket:ktx-2026-chuseok:seats:remaining Type: String (integer) Value: 100

SET ticket:ktx-2026-chuseok:seats:remaining 100

DECRBY만 쓰면 안 되는 이유: - 잔여 2석인데 3석 요청 → -1 반환 → 초과 예매 발생 Lua Script: 1. GET remaining 2. remaining >= requested 이면 DECRBY 3. 아니면 실패 반환 → 원자적으로 check-then-act

Key: ticket:ktx-2026-chuseok:booking:done:{uuid} Type: String Value: reservationId TTL: 24시간 (이벤트 종료 후 정리)

SET ticket:ktx-2026-chuseok:booking:done:a1b2c3d4 "res-12345" NX EX 86400

// scripts/init-event.ts import { redis } from '../src/config/redis'; import { keys } from '../src/redis/keys'; import { config } from '../src/config'; async function initEvent() { const eventId = config.EVENT_ID; const totalSeats = config.TOTAL_SEATS; // 잔여 좌석 초기화 (이미 있으면 덮어쓰지 않음) const seatKey = keys.remainingSeats(eventId); const exists = await redis.exists(seatKey); if (!exists) { await redis.set(seatKey, totalSeats); console.log(`[Init] 잔여 좌석 설정: ${totalSeats}`); } // 메타 정보 await redis.hset(keys.eventMeta(eventId), { totalSeats: String(totalSeats), openedAt: String(Date.now()), status: 'OPEN', }); console.log(`[Init] 이벤트 ${eventId} 초기화 완료`); await redis.quit(); } initEvent();

# Hash Tag로 관련 키를 같은 슬롯에 배치 ticket:{ktx-2026-chuseok}:queue:waiting ticket:{ktx-2026-chuseok}:active:users ticket:{ktx-2026-chuseok}:seats:remaining

// Hash Tag 적용 waitingQueue: (eventId: string) => `ticket:{${eventId}}:queue:waiting`,

대기열 200만 명 기준: - UUID (36 bytes) + score (8 bytes) + 오버헤드 ≈ 64 bytes/entry - 2,000,000 × 64 = ~128 MB Active 10만 명 (누적 최대): - 100,000 × 64 = ~6.4 MB 총 Redis 메모리: ~150 MB (대기열 단계) → 16GB Redis 인스턴스면 충분

# 대기 인원 실시간 확인 redis-cli ZCARD ticket:ktx-2026-chuseok:queue:waiting # Active 유저 수 redis-cli ZCARD ticket:ktx-2026-chuseok:active:users # 잔여 좌석 redis-cli GET ticket:ktx-2026-chuseok:seats:remaining # 메모리 사용량 redis-cli INFO memory

POST /api/queue/join HTTP/1.1 Content-Type: application/json { "eventId": "ktx-2026-chuseok" // optional, 기본값 config.EVENT_ID }

{ "success": true, "data": { "token": "f47ac10b-58cc-4372-a567-0e02b2c3d479", "eventId": "ktx-2026-chuseok", "joinedAt": 1704067200123 } }

{ "success": false, "error": { "code": "ALREADY_BOOKED", "message": "이미 예매를 완료했습니다." } }

import { v4 as uuidv4 } from 'uuid'; import { redis } from '../config/redis'; import { keys } from '../redis/keys'; import { config } from '../config'; import { AppError } from '../middleware/errorHandler'; export class QueueService { /** * 대기열 등록 * - UUID 발급 * - ZADD NX로 멱등 등록 * - 이미 예매 완료한 토큰은 거부 */ async join(eventId: string = config.EVENT_ID) { const token = uuidv4(); const now = Date.now(); // 이미 예매 완료 여부 (재접속 시 새 토큰이 아닌 기존 토큰으로 조회하는 경우 대비) // join 시점에는 새 토큰이므로 이 체크는 재등록 API에서 사용 const queueKey = keys.waitingQueue(eventId); // NX: 이미 존재하는 member는 추가하지 않음 const added = await redis.zadd(queueKey, 'NX', now, token); if (added === 0) { // 이론상 새 UUID이므로 0이 나오면 안 됨 // 동일 토큰 재사용 API가 있다면 여기서 처리 throw new AppError(500, '대기열 등록 실패', 'QUEUE_ADD_FAILED'); } return { token, eventId, joinedAt: now, }; } /** * 기존 토큰으로 대기열 재조회 (새로고침/F5 대응) * 토큰이 대기열/Active/예매완료 중 어디에 있는지 확인 */ async rejoin(token: string, eventId: string = config.EVENT_ID) { // 예매 완료 확인 const booked = await redis.exists(keys.bookingDone(token, eventId)); if (booked) { throw new AppError(409, '이미 예매를 완료했습니다.', 'ALREADY_BOOKED'); } const queueKey = keys.waitingQueue(eventId); const rank = await redis.zrank(queueKey, token); if (rank !== null) { // 이미 대기열에 있음 → 기존 순번 유지 return { token, eventId, joinedAt: null, rejoined: true }; } // Active에 있는지 확인 const activeScore = await redis.zscore(keys.activeUsers(eventId), token); if (activeScore !== null) { return { token, eventId, joinedAt: null, rejoined: true, status: 'ACTIVE' }; } // 어디에도 없으면 새로 등록 const now = Date.now(); await redis.zadd(queueKey, 'NX', now, token); return { token, eventId, joinedAt: now, rejoined: false }; } /** * 대기열에서 특정 유저 제거 (취소 기능) */ async leave(token: string, eventId: string = config.EVENT_ID) { const removed = await redis.zrem(keys.waitingQueue(eventId), token); return { removed: removed > 0 }; } } export const queueService = new QueueService();

import { Router } from 'express'; import { z } from 'zod'; import { queueService } from '../services/queue.service'; import { rateLimit } from '../middleware/rateLimit'; import { AppError } from '../middleware/errorHandler'; export const queueRouter = Router(); const joinSchema = z.object({ eventId: z.string().optional(), }); /** * POST /api/queue/join * 대기열 최초 진입 */ queueRouter.post('/join', rateLimit(10), async (req, res, next) => { try { const body = joinSchema.parse(req.body); const result = await queueService.join(body.eventId); res.status(200).json({ success: true, data: result }); } catch (err) { next(err); } }); /** * POST /api/queue/rejoin * 기존 토큰으로 재진입 (F5/새로고침 대응) */ const rejoinSchema = z.object({ token: z.string().uuid(), eventId: z.string().optional(), }); queueRouter.post('/rejoin', rateLimit(10), async (req, res, next) => { try { const body = rejoinSchema.parse(req.body); const result = await queueService.rejoin(body.token, body.eventId); res.status(200).json({ success: true, data: result }); } catch (err) { next(err); } }); /** * DELETE /api/queue/leave * 대기열 이탈 (취소) */ queueRouter.delete('/leave', rateLimit(5), async (req, res, next) => { try { const token = req.query.token as string; if (!token) throw new AppError(400, 'token 필수', 'MISSING_TOKEN'); const result = await queueService.leave(token); res.status(200).json({ success: true, data: result }); } catch (err) { next(err); } });

200만 요청 → Express N대 → Redis ZADD NX Redis ZADD 성능: ~100,000 ops/sec (단일 인스턴스) Cluster 3노드: ~300,000 ops/sec 200만 / 300,000 = ~7초 내 전부 등록 가능 (DB는 0건 접근)

// 첫 요청 ZADD queue NX 1704067200000 "uuid-abc" → 1 (추가됨) // F5 연타 (rejoin API) ZRANK queue "uuid-abc" → 0 (이미 존재, 순번 유지) // 새 토큰으로 join 연타해도 매번 새 UUID → 각각 다른 대기열 등록 // → rejoin API로 기존 토큰 유지가 정답

async join(eventId: string) { const meta = await redis.hget(keys.eventMeta(eventId), 'status'); if (meta === 'CLOSED') { throw new AppError(403, '예매가 마감되었습니다.', 'EVENT_CLOSED'); } // ... }

# 대기열 진입 curl -X POST <http://localhost:3000/api/queue/join> \ -H "Content-Type: application/json" \ -d '{}' # 응답 예시 # {"success":true,"data":{"token":"f47ac10b-58cc-4372-a567-0e02b2c3d479","eventId":"ktx-2026-chuseok","joinedAt":1704067200123}} # 재진입 (F5 대응) curl -X POST <http://localhost:3000/api/queue/rejoin> \ -H "Content-Type: application/json" \ -d '{"token":"f47ac10b-58cc-4372-a567-0e02b2c3d479"}' # 대기열 이탈 curl -X DELETE "<http://localhost:3000/api/queue/leave?token=f47ac10b-58cc-4372-a567-0e02b2c3d479>"

// scripts/load-test-join.ts import { performance } from 'perf_hooks'; const CONCURRENCY = 1000; const TOTAL = 10000; const BASE_URL = '<http://localhost:3000>'; async function join() { const res = await fetch(`${BASE_URL}/api/queue/join`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}', }); return res.json(); } async function main() { const start = performance.now(); let completed = 0; let errors = 0; const batch = async () => { const promises = Array.from({ length: CONCURRENCY }, () => join() .then(() => { completed++; }) .catch(() => { errors++; }) ); await Promise.all(promises); }; const batches = Math.ceil(TOTAL / CONCURRENCY); for (let i = 0; i < batches; i++) { await batch(); process.stdout.write(`\r${completed}/${TOTAL} (errors: ${errors})`); } const elapsed = (performance.now() - start) / 1000; console.log(`\n완료: ${completed}건, ${elapsed.toFixed(2)}초, ${(completed / elapsed).toFixed(0)} req/s`); } main();

// 대기열 진입 후 const { data } = await response.json(); localStorage.setItem('queueToken', data.token); // 이후 모든 요청에 사용 const token = localStorage.getItem('queueToken');

{ "success": true, "data": { "status": "WAITING", "rank": 502341, "totalWaiting": 1980000, "ahead": 502340, "behind": 1477659, "remainingSeats": 87, "nextPollMs": 5000, "activeExpiresAt": null } }

{ "success": true, "data": { "status": "ACTIVE", "rank": null, "totalWaiting": 1950000, "ahead": null, "behind": null, "remainingSeats": 85, "nextPollMs": 2000, "activeExpiresAt": 1704067380000 } }

{ "success": true, "data": { "status": "EXPIRED", "rank": null, "totalWaiting": 0, "ahead": null, "behind": null, "remainingSeats": 0, "nextPollMs": 0, "activeExpiresAt": null } }

import { redis } from '../config/redis'; import { keys } from '../redis/keys'; import { config } from '../config'; import { QueueStatus, StatusPollResponse } from '../types'; export class PollingService { /** * 폴링 응답 생성 * Redis 읽기만 수행 → 초경량 */ async poll(token: string, eventId: string = config.EVENT_ID) { // 1. 예매 완료 확인 const booked = await redis.exists(keys.bookingDone(token, eventId)); if (booked) { return this.buildResponse('ACTIVE', eventId, null, null); } // 2. Active User 확인 const activeKey = keys.activeUsers(eventId); const expireAtStr = await redis.zscore(activeKey, token); if (expireAtStr !== null) { const expireAt = parseInt(expireAtStr, 10); if (Date.now() < expireAt) { const remaining = await this.getRemainingSeats(eventId); const totalWaiting = await redis.zcard(keys.waitingQueue(eventId)); return this.buildResponse('ACTIVE', eventId, null, expireAt, remaining, totalWaiting); } // 만료됨 await redis.zrem(activeKey, token); return this.buildResponse('EXPIRED', eventId, null, null); } // 3. 대기열 확인 const queueKey = keys.waitingQueue(eventId); const rank = await redis.zrank(queueKey, token); if (rank === null) { return this.buildResponse('NOT_FOUND', eventId, null, null); } // 4. 순번 및 통계 (Pipeline으로 한 번에) const pipeline = redis.pipeline(); pipeline.zcard(queueKey); pipeline.get(keys.remainingSeats(eventId)); const results = await pipeline.exec(); const totalWaiting = (results?.[0]?.[1] as number) ?? 0; const remainingSeats = parseInt((results?.[1]?.[1] as string) ?? '0', 10); const rankOneBased = rank + 1; // 0-based → 1-based const ahead = rank; // 내 앞 사람 수 const behind = totalWaiting - rankOneBased; return this.buildResponse( 'WAITING', eventId, { rank: rankOneBased, ahead, behind, totalWaiting }, null, remainingSeats, totalWaiting ); } private async getRemainingSeats(eventId: string): Promise<number> { const val = await redis.get(keys.remainingSeats(eventId)); return parseInt(val ?? '0', 10); } /** * Adaptive Polling: 대기 순번에 따라 폴링 주기 결정 */ private calcNextPollMs(status: QueueStatus, rank: number | null): number { if (status === 'ACTIVE') return 2000; if (status === 'EXPIRED' || status === 'NOT_FOUND') return 0; if (rank === null) return 5000; // SRT/KTX처럼 서버가 폴링 주기를 제어 if (rank > 100000) return 10000; // 10초 if (rank > 10000) return 5000; // 5초 if (rank > 1000) return 3000; // 3초 if (rank > 100) return 2000; // 2초 return 1000; // 1초 } private buildResponse( status: QueueStatus, eventId: string, rankInfo: { rank: number; ahead: number; behind: number; totalWaiting: number } | null, activeExpiresAt: number | null, remainingSeats: number = 0, totalWaiting: number = 0 ) { const nextPollMs = this.calcNextPollMs(status, rankInfo?.rank ?? null); // Jitter: ±20% 랜덤 오프셋 (동시 폴링 분산) const jitter = nextPollMs > 0 ? Math.floor(nextPollMs * (0.8 + Math.random() * 0.4)) : 0; return { success: true as const, data: { status, rank: rankInfo?.rank ?? null, totalWaiting: rankInfo?.totalWaiting ?? totalWaiting, ahead: rankInfo?.ahead ?? null, behind: rankInfo?.behind ?? null, remainingSeats, nextPollMs: jitter, activeExpiresAt, }, }; } } export const pollingService = new PollingService();

import { Router } from 'express'; import { z } from 'zod'; import { pollingService } from '../services/polling.service'; import { AppError } from '../middleware/errorHandler'; export const statusRouter = Router(); const pollSchema = z.object({ token: z.string().uuid(), eventId: z.string().optional(), }); /** * GET /api/status/poll?token=xxx * 대기 상태 폴링 */ statusRouter.get('/poll', async (req, res, next) => { try { const query = pollSchema.parse(req.query); const result = await pollingService.poll(query.token, query.eventId); res.status(200).json(result); } catch (err) { next(err); } });

// Bad: 3번 왕복 (3 × RTT) const rank = await redis.zrank(key, token); const total = await redis.zcard(key); const seats = await redis.get(seatKey); // Good: 1번 왕복 (1 × RTT) const pipeline = redis.pipeline(); pipeline.zrank(key, token); pipeline.zcard(key); pipeline.get(seatKey); const results = await pipeline.exec();

Redis RTT: ~0.5ms (같은 AZ) Pipeline 없이 3명령: 1.5ms Pipeline 1번: 0.5ms 폴링 100,000 req/s 기준: - Pipeline 없음: 150ms 처리 지연 - Pipeline: 50ms 처리 지연

# 200만 명 대기열 ZCARD ticket:ktx:queue:waiting → 2000000 (O(1) - 내부 카운터 유지) ZRANK ticket:ktx:queue:waiting "my-uuid" → 502340 (O(log N) - skip list) # 내 앞: 502340명 # 내 뒤: 2000000 - 502341 = 1477659명

가정: - 대기 중 사용자: 150만 명 - 평균 폴링 주기: 5초 - 폴링 QPS = 1,500,000 / 5 = 300,000 req/s 각 폴링 요청: - Redis Pipeline 3~4 명령 - DB 접근: 0 - 응답 크기: ~200 bytes → API 서버 10대 (각 30,000 req/s)로 처리 가능 → Redis Cluster 3노드 (각 100,000 ops/s)로 충분

TOKEN="f47ac10b-58cc-4372-a567-0e02b2c3d479" # 폴링 curl "<http://localhost:3000/api/status/poll?token=$TOKEN>" # 응답에서 nextPollMs 확인 후 그만큼 대기하고 재호출

응답 필드: - ahead: 내 앞 대기 인원 - behind: 내 뒤 대기 인원 - TTL: 서버가 지정한 다음 폴링 주기 (1~2초) - 키: 매 호출마다 갱신되는 서명 토큰 (재사용 방지) - Content-Type: application/javascript (JSONP 방식)

// 토큰이 없는 경우 if (rank === null && activeScore === null && !booked) { return { status: 'NOT_FOUND', nextPollMs: 0 }; // 클라이언트: 대기열 재등록 (/api/queue/rejoin) 유도 } // 이벤트 종료 const eventStatus = await redis.hget(keys.eventMeta(eventId), 'status'); if (eventStatus === 'CLOSED') { return { status: 'EXPIRED', nextPollMs: 0 }; }

batchSize = RDB_TPS × safetyRatio × schedulerInterval 예시: - RDB 예매 처리 TPS = 100건/초 (부하 테스트 결과) - safetyRatio = 0.7 (70%만 입장 허용) - schedulerInterval = 1초 batchSize = 100 × 0.7 × 1 = 70명/초

-- pop-queue.lua -- 대기열에서 N명을 원자적으로 꺼내 Active User로 이동 local waitingKey = KEYS[1] -- waiting queue local activeKey = KEYS[2] -- active users local batchSize = tonumber(ARGV[1]) local expireAt = tonumber(ARGV[2]) -- now + TTL local results = {} local popped = redis.call('ZPOPMIN', waitingKey, batchSize) -- ZPOPMIN 결과: [member1, score1, member2, score2, ...] for i = 1, #popped, 2 do local member = popped[i] local score = popped[i + 1] redis.call('ZADD', activeKey, expireAt, member) table.insert(results, member) end -- 만료된 active user 정리 local now = tonumber(ARGV[3]) redis.call('ZREMRANGEBYSCORE', activeKey, '-inf', now) return results

import { redis } from '../config/redis'; import { evalLua } from '../config/redis'; import { keys } from '../redis/keys'; import { config } from '../config'; export class EntryService { /** * 대기열 → Active User 이동 (원자적) */ async processEntry(eventId: string = config.EVENT_ID) { const now = Date.now(); const expireAt = now + config.ACTIVE_USER_TTL_SEC * 1000; const batchSize = config.ENTRY_BATCH_SIZE; const waitingKey = keys.waitingQueue(eventId); const activeKey = keys.activeUsers(eventId); // 대기열이 비었으면 스킵 const queueSize = await redis.zcard(waitingKey); if (queueSize === 0) { return { processed: 0, tokens: [] }; } const result = await evalLua( 'pop-queue', 2, waitingKey, activeKey, batchSize, expireAt, now ) as string[]; return { processed: result.length, tokens: result, }; } /** * Active User 여부 확인 */ async isActive(token: string, eventId: string = config.EVENT_ID): Promise<boolean> { const score = await redis.zscore(keys.activeUsers(eventId), token); if (score === null) return false; return Date.now() < parseInt(score, 10); } /** * 만료된 Active User 수 조회 (모니터링) */ async countExpired(eventId: string = config.EVENT_ID): Promise<number> { const now = Date.now(); const activeKey = keys.activeUsers(eventId); // score < now 인 멤버 수 const all = await redis.zrangebyscore(activeKey, '-inf', now); return all.length; } } export const entryService = new EntryService();

import cron from 'node-cron'; import { entryService } from '../services/entry.service'; import { config } from '../config'; import { redis } from '../config/redis'; let isRunning = false; async function tick() { // 중복 실행 방지 (이전 tick이 아직 실행 중이면 스킵) if (isRunning) { console.warn('[Scheduler] 이전 tick 실행 중, 스킵'); return; } isRunning = true; try { const result = await entryService.processEntry(); if (result.processed > 0) { console.log(`[Scheduler] ${result.processed}명 입장 처리`); } } catch (err) { console.error('[Scheduler] 오류:', err); } finally { isRunning = false; } } async function main() { await redis.ping(); console.log('[Scheduler] Redis 연결 OK'); console.log(`[Scheduler] batchSize=${config.ENTRY_BATCH_SIZE}, TTL=${config.ACTIVE_USER_TTL_SEC}s`); // 1초마다 실행 (node-cron 6필드: 초 분 시 일 월 요일) cron.schedule('*/1 * * * * *', tick); console.log('[Scheduler] 시작됨'); } // Graceful shutdown process.on('SIGTERM', async () => { console.log('[Scheduler] 종료 중...'); await redis.quit(); process.exit(0); }); main().catch(console.error);