使用Ktor开发自定义API网关遇服务宕机触发调用循环问题求助

问题描述 #

用Ktor开发自定义网关API，通过工厂类根据请求路径转发至特定服务，当前遇到的问题是：后端服务宕机时会触发调用循环，仅能通过速率限制终止，怀疑HttpClient使用方式或架构设计存在问题。

代码实现 #

fun Application.configureRouting() {
    val client = HttpClient() {
        expectSuccess = true
        followRedirects = false
    }
    routing {
        route("/") {
            post("{...}") {
                val reqUriPaths = call.request.uri  // <--- 循环起始处
                serviceLog.info("request: $reqUriPaths")
                val serviceUrl: String = RoutingFactory.serviceUrlFromUri(reqUriPaths) ?: run {
                    serviceLog.error("Unable to recover path from: $reqUriPaths", Exception())
                    call.respond(HttpStatusCode.BadRequest, "Unable to recover path")
                    return@post
                }
                try {
                    val backendResponse: HttpResponse = withContext(Dispatchers.IO) {
                        client.request("$serviceUrl$reqUriPaths") { //<--- 问题所在
                            method = HttpMethod.Post
                            call.request.headers.forEach { header, values ->
                                headers.appendAll(header, values)
                            }
                            contentType(ContentType.Application.Json)
                            val body = call.receiveText()
                            setBody(body)

                            serviceLog.info("execution context: $executionContext")

                        }
                    }
                    val body = backendResponse.bodyAsText()
                    serviceLog.info("auth response service: ${backendResponse.status}")
                    call.respond(backendResponse.status, body)
                } catch (e: Exception) {
                    serviceLog.error("Error communicating with auth service: ${e.message}", e)
                    call.respond(HttpStatusCode.InternalServerError, "Internal server error")
                }

            }
        }
    }
}

class RoutingFactory {
    companion object {
        fun serviceUrlFromUri(uri: String): String? {
            val servicePath = uri.split("/").getOrNull(1) ?: return null
            return when (servicePath) {
                "user" -> "http://auth:8080"
                else -> null
            }
        }
    }
}

错误日志 #

INFO APIGateway - 请求: /user
INFO APIGateway - 执行上下文: SupervisorJobImpl{Active}@3d60ee26
INFO APIGateway - 请求: /user
INFO APIGateway - 执行上下文: SupervisorJobImpl{Active}@6b7a58a9
INFO APIGateway - 请求: /user
INFO APIGateway - 执行上下文: SupervisorJobImpl{Active}@452be7d9
INFO APIGateway - 请求: /user
INFO APIGateway - 执行上下文: SupervisorJobImpl{Active}@79ceb296
INFO APIGateway - 请求: /user
INFO APIGateway - 执行上下文: SupervisorJobImpl{Active}@7dbfead6
ERROR APIGateway - 与认证服务通信时出错：客户端请求(POST http://auth:8080/user)无效：429 请求过多。文本：""
io.ktor.client.plugins.ClientRequestException: 客户端请求(POST http://auth:8080/user)无效：429 请求过多。文本：""
APIGateway - 与认证服务通信时出错：客户端请求(POST http://auth:8080/user)无效：404 未找到。文本：""
io.ktor.client.plugins.ClientRequestException: 客户端请求(POST http://auth:8080/user)无效：404 未找到。文本：""
ERROR APIGateway - 与认证服务通信时出错：客户端请求(POST http://auth:8080/user)无效：404 未找到。文本：""
io.ktor.client.plugins.ClientRequestException: 客户端请求(POST http://auth:8080/user)无效：404 未找到。文本：""
ERROR APIGateway - 与认证服务通信时出错：客户端请求(POST http://auth:8080/user)无效：404 未找到。文本：""
io.ktor.client.plugins.ClientRequestException: 客户端请求(POST http://auth:8080/user)无效：404 未找到。文本：""
ERROR APIGateway - 与认证服务通信时出错：客户端请求(POST http://auth:8080/user)无效：404 未找到。文本：""
io.ktor.client.plugins.ClientRequestException: 客户端请求(POST http://auth:8080/user)无效：404 未找到。文本：""

问题原因 #

1. 路由过度匹配：使用post("{...}")贪婪匹配所有路径，当网关返回500错误时，若客户端开启自动重试，会持续发送相同请求，网关不断匹配处理形成循环。
2. HttpClient缺少超时与重试控制：未配置请求超时和重试次数限制，后端无响应时HttpClient不会主动终止请求，叠加客户端重试导致循环调用。
3. 错误响应无重试控制：返回500错误时未告知客户端合理的重试间隔，导致客户端频繁重试。

修复方案 #

1. 优化路由匹配精度 #

将贪婪匹配改为精确前缀匹配，避免非预期请求被重复处理：

routing {
    route("/") {
        // 匹配带服务前缀的路径，比如/user/xxx
        post("/{servicePath}/{...}") {
            val servicePath = call.parameters["servicePath"] ?: run {
                serviceLog.error("无效的服务路径")
                call.respond(HttpStatusCode.BadRequest, "无效的服务路径")
                return@post
            }
            val serviceUrl = when (servicePath) {
                "user" -> "http://auth:8080"
                else -> {
                    serviceLog.error("未知服务: $servicePath")
                    call.respond(HttpStatusCode.BadRequest, "未知服务")
                    return@post
                }
            }
            // 后续转发逻辑...
        }
    }
}

2. 配置HttpClient超时与重试策略 #

添加超时限制和可控的重试规则，避免无等待和重复调用：

val client = HttpClient() {
    expectSuccess = true
    followRedirects = false
    // 超时配置
    install(HttpTimeout) {
        requestTimeoutMillis = 5000 // 5秒请求超时
        connectTimeoutMillis = 2000 // 2秒连接超时
        socketTimeoutMillis = 3000 // 3秒套接字超时
    }
    // 重试控制
    install(Retry) {
        maxRetries = 2 // 最多重试2次
        delayMillis { retryCount ->
            // 指数退避，重试间隔依次为1s、2s
            (1000 * retryCount).toLong()
        }
        retryOnExceptionIf { _, exception ->
            exception is IOException // 仅网络异常时重试
        }
        retryOnStatusCodes { status ->
            status.value in 500..599 // 仅服务器错误时重试
        }
    }
}

3. 错误响应添加重试控制头 #

返回500错误时，通过Retry-After头告知客户端重试间隔：

catch (e: Exception) {
    serviceLog.error("与认证服务通信时出错: ${e.message}", e)
    call.response.headers.append("Retry-After", "10") // 10秒后再重试
    call.respond(HttpStatusCode.InternalServerError, "内部服务器错误")
}

4. 优化路径转发逻辑（可选） #

拆分原URI，避免服务前缀重复拼接：

val reqUriPaths = call.request.uri
val servicePath = reqUriPaths.split("/").getOrNull(1) ?: return@post
val targetPath = reqUriPaths.substringAfter("/$servicePath", "")
// 转发到http://auth:8080/xxx 而非http://auth:8080/user/xxx
client.request("$serviceUrl$targetPath") {
    // ... 其他配置
}

验证效果 #

修复后，后端服务宕机时：

• HttpClient会在超时后终止请求，最多重试2次
• 网关返回500并带上Retry-After头，客户端不会立即重试
• 精确路由匹配避免非预期请求被重复处理

内容的提问来源于stack exchange，提问作者Thorny84