[1편] 간단한 메시지 큐에서 멀티 테넌트 시스템까지

// 정말로 이것부터 시작했습니다
@RestController
class SimpleQueueController {
    private val messages = mutableListOf<String>()
    
    @PostMapping("/send")
    fun sendMessage(@RequestBody message: String): String {
        messages.add(message)
        return "메시지 전송 완료"
    }
    
    @GetMapping("/receive")
    fun receiveMessage(): String? {
        return if (messages.isNotEmpty()) {
            messages.removeAt(0)
        } else {
            null
        }
    }
}

// Redis로 저장하도록 개선
@RestController
class QueueController(
    private val redisTemplate: RedisTemplate<String, String>
) {
    @PostMapping("/send")
    fun sendMessage(@RequestBody message: String): String {
        redisTemplate.opsForList().rightPush("simple-queue", message)
        return "메시지 저장 완료"
    }
    
    @GetMapping("/receive")
    fun receiveMessage(): String? {
        return redisTemplate.opsForList().leftPop("simple-queue")
    }
}

// 메시지 수신 시 InFlight 추가
// => 다음 수신 시 만료된 메시지를 복원하는 로직부터 실행 or 스케줄러에서 주기적으로 복원
private fun addToInFlight(queue: Queue, message: Message): Mono<Long> {
    val score = message.visibleAt.epochSecond.toDouble()
    val value = "${message.messageId}:${message.receiptHandle}"
    return redisTemplate.opsForZSet()
        .add(queue.getInFlightKey(), value, score)
        .map { if (it) 1L else 0L }
}

private fun addToQueue(queue: Queue, message: Message): Mono<Long> {
    return if (message.visibleAt > Instant.now()) {
        // 지연된 메시지는 delayed queue에 추가
        val score = message.visibleAt.epochSecond.toDouble()
        redisTemplate.opsForZSet()
            .add(queue.getDelayedKey(), message.messageId, score)
            .map { if (it) 1L else 0L }
    } else {
        // 즉시 처리 가능한 메시지는 available queue에 추가
        redisTemplate.opsForList()
            .rightPush(queue.getMessagesKey(), message.messageId)
    }
}

// 테넌트 엔티티 정의
data class Tenant(
    val tenantId: String,
    val apiKey: String,
    val name: String,
    val createdAt: Instant,
    val isActive: Boolean = true
)

// API Key 기반 인증 필터
@Component
class ApiKeyAuthenticationFilter(
    private val tenantService: TenantService,
    private val objectMapper: ObjectMapper
) : WebFilter {
    ......
}

// Before: 전역 네임스페이스
"queue:my-queue"
"queue:messages:my-queue"

// After: 테넌트별 네임스페이스  
"tenant:{tenantId}:queue:my-queue"
"tenant:{tenantId}:queue:messages:my-queue"
"tenant:{tenantId}:queue:delayed:my-queue"

┌─────────────────────────────────────────────────────────────┐
│                    Client Applications                      │
│                 (팀별로 각자의 API Key로 접근)                   │
└────────────────────────────┬────────────────────────────────┘
                             │ HTTP/REST API
┌────────────────────────────▼────────────────────────────────┐
│                  API Gateway Layer                          │
│          - 인증: "이 API Key는 어느 테넌트의 것인가?"              │
│          - 격리: "테넌트별로 완전히 분리된 네임스페이스"               │
└────────────────────────────┬────────────────────────────────┘
                             │
┌────────────────────────────▼────────────────────────────────┐
│              Multi-Tenant Application Layer                 │
│   ┌─────────────┐ ┌─────────────┐ ┌─────────────┐           │
│   │   Queue     │ │   Message   │ │   Tenant    │           │
│   │ Controller  │ │ Controller  │ │ Controller  │           │
│   └─────────────┘ └─────────────┘ └─────────────┘           │
└─────────────────────────────┬───────────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────────┐
│               Tenant-Aware Storage Layer                    │
│  tenant:{tenantId}:queue:{queueName}                        │
│  tenant:{tenantId}:messages:{queueName}                     │
│  tenant:{tenantId}:delayed:{queueName}                      │
└─────────────────────────────────────────────────────────────┘

// 1. 테넌트 생성
POST /admin/tenants
{
  "name": "backend-team",
  "description": "백엔드 팀 전용 큐"
}
// 응답: { "apiKey": "sk-abc123..." }

// 2. 해당 테넌트에서 큐 생성  
POST /api/v1/queues
Headers: X-API-Key: sk-abc123...
{
  "queueName": "order-processing"
}

// 3. 메시지 전송 (테넌트별로 완전 격리됨)
POST /api/v1/queues/order-processing/messages
Headers: X-API-Key: sk-abc123...
{
  "messageBody": "주문 처리 요청"
}

// 큐 목록 조회 API 추가
@GetMapping("/queues")
fun listQueues(
    @RequestParam(defaultValue = "20") limit: Int,
    @RequestParam(defaultValue = "0") offset: Int,
    @RequestParam(required = false) namePattern: String?
): Mono<ApiResponse<QueueListResponse>> {
    return queueService.listQueues(limit, offset, namePattern)
        .map { ApiResponse.success(it) }
}

// 큐 생성 시 DLQ 설정 가능하도록
data class CreateQueueRequest(
    val queueName: String,
    val attributes: QueueAttributes = QueueAttributes()
)

data class QueueAttributes(
    val visibilityTimeoutSeconds: Int = 30,
    val maxReceiveCount: Int = 3,
    val deadLetterTargetArn: String? = null // DLQ 이름
)