feat: CircuitBreaker 패턴 적용 QUZ-122

HMWG · HMWG · commit 12684cd44e7b · 2024-12-06T21:48:44.000+09:00
diff --git a/gateway-service/build.gradle.kts b/gateway-service/build.gradle.kts
@@ -19,8 +19,12 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-starter-security")
     testImplementation("org.springframework.security:spring-security-test")
 
-    //redis
+    // Redis
     implementation("org.springframework.boot:spring-boot-starter-data-redis-reactive")
+
+    // Circuit Breaker
+    implementation("org.springframework.cloud:spring-cloud-starter-circuitbreaker-reactor-resilience4j:3.1.0")
+
 }
 
 tasks.named<BootJar>("bootJar") {
diff --git a/gateway-service/src/main/kotlin/com/grepp/quizy/api/GatewayFallbackController.kt b/gateway-service/src/main/kotlin/com/grepp/quizy/api/GatewayFallbackController.kt
@@ -0,0 +1,52 @@
+package com.grepp.quizy.api
+
+import com.grepp.quizy.common.api.ApiResponse
+import org.springframework.http.HttpStatus
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/fallback")
+class GatewayFallbackController {
+    @GetMapping("/user")
+    fun userServiceFallback(): ResponseEntity<ApiResponse<Unit>> {
+        return ResponseEntity
+            .status(HttpStatus.SERVICE_UNAVAILABLE)
+            .body(ApiResponse.error(HttpStatus.SERVICE_UNAVAILABLE.name, "User service is temporarily unavailable"))
+    }
+
+    @GetMapping("/quiz")
+    fun quizServiceFallback(): ResponseEntity<ApiResponse<Unit>> {
+        return ResponseEntity
+            .status(HttpStatus.SERVICE_UNAVAILABLE)
+            .body(ApiResponse.error(HttpStatus.SERVICE_UNAVAILABLE.name, "Quiz service is temporarily unavailable"))
+    }
+
+    @GetMapping("/game")
+    fun gameServiceFallback(): ResponseEntity<ApiResponse<Unit>> {
+        return ResponseEntity
+            .status(HttpStatus.SERVICE_UNAVAILABLE)
+            .body(ApiResponse.error(HttpStatus.SERVICE_UNAVAILABLE.name, "Game service is temporarily unavailable"))
+    }
+
+    @GetMapping("/ws")
+    fun webSocketServiceFallback(): ResponseEntity<ApiResponse<Unit>> {
+        return ResponseEntity
+            .status(HttpStatus.SERVICE_UNAVAILABLE)
+            .body(
+                ApiResponse.error(
+                    HttpStatus.SERVICE_UNAVAILABLE.name,
+                    "Game webSocket service is temporarily unavailable"
+                )
+            )
+    }
+
+    @GetMapping("/matching")
+    fun matchingServiceFallback(): ResponseEntity<ApiResponse<Unit>> {
+        return ResponseEntity
+            .status(HttpStatus.SERVICE_UNAVAILABLE)
+            .body(ApiResponse.error(HttpStatus.SERVICE_UNAVAILABLE.name, "Matching service is temporarily unavailable"))
+    }
+}
diff --git a/gateway-service/src/main/kotlin/com/grepp/quizy/global/AuthGlobalFilter.kt b/gateway-service/src/main/kotlin/com/grepp/quizy/global/AuthGlobalFilter.kt
@@ -6,7 +6,7 @@ import com.grepp.quizy.jwt.JwtValidator
 import com.grepp.quizy.user.RedisTokenRepository
 import com.grepp.quizy.user.UserId
 import com.grepp.quizy.user.api.global.util.CookieUtils
-import com.grepp.quizy.web.UserClient
+import com.grepp.quizy.webclient.UserClient
 import org.slf4j.LoggerFactory
 import org.springframework.cloud.gateway.filter.GatewayFilterChain
 import org.springframework.cloud.gateway.filter.GlobalFilter
diff --git a/gateway-service/src/main/kotlin/com/grepp/quizy/webclient/UserClient.kt b/gateway-service/src/main/kotlin/com/grepp/quizy/webclient/UserClient.kt
@@ -0,0 +1,7 @@
+package com.grepp.quizy.webclient
+
+import reactor.core.publisher.Mono
+
+interface UserClient {
+    fun validateUser(userId: Long): Mono<Unit>
+}
diff --git a/gateway-service/src/main/kotlin/com/grepp/quizy/webclient/UserClientImpl.kt b/gateway-service/src/main/kotlin/com/grepp/quizy/webclient/UserClientImpl.kt
@@ -0,0 +1,39 @@
+package com.grepp.quizy.webclient
+
+import com.grepp.quizy.exception.CustomJwtException
+import com.grepp.quizy.user.RedisTokenRepository
+import com.grepp.quizy.user.UserId
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.http.HttpStatus
+import org.springframework.stereotype.Component
+import org.springframework.web.reactive.function.client.WebClient
+import reactor.core.publisher.Mono
+
+@Component
+class UserClientImpl(
+    private val webClient: WebClient,
+    private val redisTokenRepository: RedisTokenRepository
+) : UserClient {
+
+    @Value("\${service.user.url}")
+    private lateinit var BASE_URL: String
+
+
+    override fun validateUser(userId: Long): Mono<Unit> {
+        if (redisTokenRepository.isExistUser(UserId(userId))) {
+            return Mono.just(Unit)
+        }
+
+        return webClient.get()
+            .uri("$BASE_URL/api/internal/user/validate/$userId")
+            .retrieve()
+            .toEntity(Unit::class.java)
+            .handle<Unit> { response, sink ->
+                when (response.statusCode) {
+                    HttpStatus.OK -> sink.next(Unit)
+                    HttpStatus.UNAUTHORIZED -> sink.error(CustomJwtException.JwtUnknownException)
+                    else -> sink.error(CustomJwtException.NotExistUserException)
+                }
+            }
+    }
+}
diff --git a/gateway-service/src/main/resources/application.yml b/gateway-service/src/main/resources/application.yml
@@ -4,7 +4,7 @@ management:
   endpoints:
     web:
       exposure:
-        include: health, info
+        include: health, info, circuitbreakers
 springdoc:
   swagger-ui:
     use-root-path: true
@@ -46,6 +46,46 @@ spring:
               - "*"
             allowCredentials: true
 
+resilience4j:
+  circuitbreaker:
+    configs:
+      default:
+        slidingWindowSize: 10
+        failureRateThreshold: 50
+        waitDurationInOpenState: 60000
+        permittedNumberOfCallsInHalfOpenState: 3
+        record-exceptions:
+          - java.io.IOException
+          - java.util.concurrent.TimeoutException
+    instances:
+      userServiceCircuitBreaker:
+        baseConfig: default
+      gameServiceCircuitBreaker:
+        baseConfig: default
+      matchingServiceCircuitBreaker:
+        baseConfig: default
+      quizServiceCircuitBreaker:
+        baseConfig: default
+      wsCircuitBreaker:
+        baseConfig: default
+  timelimiter:
+    configs:
+      default:
+        timeoutDuration: 4s
+      SSE:
+        timeoutDuration: 86400s  # 24시간 또는 적절한 값으로 설정
+    instances:
+      userServiceCircuitBreaker:
+        baseConfig: default
+      gameServiceCircuitBreaker:
+        baseConfig: default
+      matchingServiceCircuitBreaker:
+        baseConfig: SSE
+      quizServiceCircuitBreaker:
+        baseConfig: default
+      wsCircuitBreaker:
+        baseConfig: SSE
+
 ---
 spring:
   config:
@@ -57,29 +97,53 @@ spring:
         - id: game
           uri: http://localhost:8081
           predicates:
-            - Path=/api/game/**, /ws/**
+            - Path=/api/game/**
+          filters:
+            - name: RequestRateLimiter
+              args:
+                redis-rate-limiter.replenishRate: 10
+                redis-rate-limiter.burstCapacity: 20
+                redis-rate-limiter.requestedTokens: 1
+                key-resolver: "#{@userKeyResolver}"
+            - name: CircuitBreaker
+              args:
+                name: gameServiceCircuitBreaker
+                fallbackUri: forward:/fallback/game
+
+        - id: webSocket
+          uri: http://localhost:8081
+          predicates:
+            - Path=/ws/**
           filters:
             - name: RequestRateLimiter
               args:
                 redis-rate-limiter.replenishRate: 10
                 redis-rate-limiter.burstCapacity: 20
                 redis-rate-limiter.requestedTokens: 1
                 key-resolver: "#{@userKeyResolver}"
+            - name: CircuitBreaker
+              args:
+                name: wsCircuitBreaker
+                fallbackUri: forward:/fallback/ws
 
         - id: matching
           uri: http://localhost:8082
           predicates:
             - Path=/api/matching/**
           metadata:
-            response-timeout: 300000
-            connect-timeout: 300000
+            response-timeout: 330000
+            connect-timeout: 330000
           filters:
             - name: RequestRateLimiter
               args:
                 redis-rate-limiter.replenishRate: 10
                 redis-rate-limiter.burstCapacity: 20
                 redis-rate-limiter.requestedTokens: 1
                 key-resolver: "#{@userKeyResolver}"
+            - name: CircuitBreaker
+              args:
+                name: matchingServiceCircuitBreaker
+                fallbackUri: forward:/fallback/matching
 
         - id: quiz
           uri: http://localhost:8083
@@ -92,6 +156,10 @@ spring:
                 redis-rate-limiter.burstCapacity: 20
                 redis-rate-limiter.requestedTokens: 1
                 key-resolver: "#{@userKeyResolver}"
+            - name: CircuitBreaker
+              args:
+                name: quizServiceCircuitBreaker
+                fallbackUri: forward:/fallback/quiz
 
         - id: user
           uri: http://localhost:8085
@@ -104,6 +172,10 @@ spring:
                 redis-rate-limiter.burstCapacity: 20
                 redis-rate-limiter.requestedTokens: 1
                 key-resolver: "#{@userKeyResolver}"
+            - name: CircuitBreaker
+              args:
+                name: userServiceCircuitBreaker
+                fallbackUri: forward:/fallback/user
 
   data:
     redis:
@@ -151,29 +223,53 @@ spring:
         - id: game
           uri: http://dev-game-service:8080
           predicates:
-            - Path=/api/game/**, /ws/**
+            - Path=/api/game/**
           filters:
             - name: RequestRateLimiter
               args:
                 redis-rate-limiter.replenishRate: 10
                 redis-rate-limiter.burstCapacity: 20
                 redis-rate-limiter.requestedTokens: 1
                 key-resolver: "#{@userKeyResolver}"
+            - name: CircuitBreaker
+              args:
+                name: gameServiceCircuitBreaker
+                fallbackUri: forward:/fallback/game
+
+        - id: webSocket
+          uri: http://dev-game-service:8080
+          predicates:
+            - Path=/ws/**
+          filters:
+            - name: RequestRateLimiter
+              args:
+                redis-rate-limiter.replenishRate: 10
+                redis-rate-limiter.burstCapacity: 20
+                redis-rate-limiter.requestedTokens: 1
+                key-resolver: "#{@userKeyResolver}"
+            - name: CircuitBreaker
+              args:
+                name: wsCircuitBreaker
+                fallbackUri: forward:/fallback/ws
 
         - id: matching
           uri: http://dev-matching-service:8080
           predicates:
             - Path=/api/matching/**
           metadata:
-            response-timeout: 300000
-            connect-timeout: 300000
+            response-timeout: 330000
+            connect-timeout: 330000
           filters:
             - name: RequestRateLimiter
               args:
                 redis-rate-limiter.replenishRate: 10
                 redis-rate-limiter.burstCapacity: 20
                 redis-rate-limiter.requestedTokens: 1
                 key-resolver: "#{@userKeyResolver}"
+            - name: CircuitBreaker
+              args:
+                name: matchingServiceCircuitBreaker
+                fallbackUri: forward:/fallback/matching
 
         - id: quiz
           uri: http://dev-quiz-service:8080
@@ -186,6 +282,10 @@ spring:
                 redis-rate-limiter.burstCapacity: 20
                 redis-rate-limiter.requestedTokens: 1
                 key-resolver: "#{@userKeyResolver}"
+            - name: CircuitBreaker
+              args:
+                name: quizServiceCircuitBreaker
+                fallbackUri: forward:/fallback/quiz
 
         - id: user
           uri: http://dev-user-service:8080
@@ -198,6 +298,10 @@ spring:
                 redis-rate-limiter.burstCapacity: 20
                 redis-rate-limiter.requestedTokens: 1
                 key-resolver: "#{@userKeyResolver}"
+            - name: CircuitBreaker
+              args:
+                name: userServiceCircuitBreaker
+                fallbackUri: forward:/fallback/user
 
     kubernetes:
       discovery:
