jk 自慰 使用 Swift 搭建一个 HTTP 代理

我将通过这篇著作胪陈一下怎样用Swift搭建一个HTTP代理办事器。本文将使用Hummingbird[1]动作办事端的基本HTTP框架jk 自慰，以及使用AsyncHTTPClient[2]动作Swift的HTTP客户端来央求贪图办事。

代理办事器是一个搭载在客户端和另一个办事端(背面咱们成为贪图办事端)的中间办事器，它从客户端转发音问到贪图办事端，而况从贪图办事端获得反映信息传回给客户端。在转发音问之前，它不错以某种样式处理这些音问，相同，它也不错处理复返的反映。

在本文中，咱们将构建一个只将HTTP数据包转发到贪图办事的代理办事器。您不错在这里找到本文的示例代码。

咱们使用Hummingbird模板技俩[3] 刻下最低版块适配 Swift5.5 动作咱们办事的启动模板。读者不错选拔clone这个存储库，或者径直点击Github技俩主页上use this template按钮来创建咱们我方的存储库。用这个模板技俩创建一个办事端而况启动它，不错使用一些领域台选项和文献来配置咱们的诓骗。详见here[4]

咱们将把AsyncHTTPClient动作依赖加入Package.swift以便咱们背面来使用

dependencies: jk 自慰[     ...     .package(url: "https://github.com/swift-server/async-http-client.git"， from: "1.6.0")， ]， 

然后在贪图依赖也添加一下

targets: [     .executableTarget(name: "App"，         dependencies: [             ...             .product(name: "AsyncHTTPClient"， package: "async-http-client")，         ]， 

咱们将把HTTPClient动作HBApplicatipn的推广。这么便捷咱们治理HTTPClient的人命周期以及在HTTPClient删除前调用syncShutdown方法。

extension HBApplication {     var httpClient: HTTPClient {         get { self.extensions.get(\.httpClient) }         set { self.extensions.set(\.httpClient， value: newValue) { httpClient in             try httpClient.syncShutdown()         }}     } } 

当HBApplication关闭时刻会调用set内部的闭包。这意味着咱们当咱们援用了HBApplication，即使不使用HTTPClient，咱们也有权限去调用它

咱们将把咱们的代理办事器动作中间件。中间件将获得一个央求，然后将它发送到贪图办事器而况从贪图办事器获得反映信息。底下使咱们启动版块的中间件，它需要HTTPClient和贪图办事器的URL两个参数。

struct HBProxyServerMiddleware: HBMiddleware {     let httpClient: HTTPClient     let target: String      func apply(to request: HBRequest， next: HBResponder) -> EventLoopFuture<HBResponse> {         return httpClient.execute(             request: request，             eventLoop: .delegateAndChannel(on: request.eventLoop)，             logger: request.logger         )     } } 

当今咱们有了HTTPClient和HBProxyServerMiddleware中间件，咱们将它们加入配置文献HBApplication.configure。然后树立咱们代理办事地址为http://httpbin.org

func configure(_ args: AppArguments) throws {     self.httpClient = HTTPClient(eventLoopGroupProvider: .shared(self.eventLoopGroup))     self.middleware.add(HBProxyServerMiddleware(httpClient: self.httpClient， target: "http://httpbin.org")) } 

当咱们完成上头的手艺，构建会清晰失败。因为咱们还需要退换Hummingbird和AsyncHTTPClient之间的请乞降反映类型。同期咱们需要吞并贪图办事的URL到央求里。

为了将Hummingbird HBRequest转动为AsyncHTTPClient HTTPClient.Request，

原因: 咱们领先需要整理可能仍在加载的HBRequest的body信息，退换经过是异步的

治理有贪图:是以它需要复返一个包含背面退换斥逐的EventLoopFuture，让咱们将退换函数放到HBRequest内部

extension HBRequest {     func ahcRequest(host: String) -> EventLoopFuture<HTTPClient.Request> {         // consume request body and then construct AHC Request once we have the         // result. The URL for the request is the target server plus the URI from         // the `HBRequest`.         return self.body.consumeBody(on: self.eventLoop).flatMapThrowing { buffer in             return try HTTPClient.Request(                 url: host + self.uri.description，                 method: self.method，                 headers: self.headers，                 body: buffer.map { .byteBuffer($0) }             )         }     } } 

从HTTPClient.Response到HBResponse的退换颠倒简短

extension HTTPClient.Response {     var hbResponse: HBResponse {         return .init(             status: self.status，             headers: self.headers，             body: self.body.map { HBResponseBody.byteBuffer($0) } ?? .empty         )     } } 

咱们当今将这两个退换手艺加入HBProxyServerMiddleware的apply函数中。同期加入一些日记打印信息

func apply(to request: HBRequest， next: HBResponder) -> EventLoopFuture<HBResponse> {     // log request     request.logger.info("Forwarding \(request.uri.path)")     // convert to HTTPClient.Request， execute， convert to HBResponse     return request.ahcRequest(host: target).flatMap { ahcRequest in         httpClient.execute(             request: ahcRequest，             eventLoop: .delegateAndChannel(on: request.eventLoop)，             logger: request.logger         )     }.map { response in         return response.hbResponse     } } 

当今应该不错当年编译了。中间件将整理HBRequest的央求体，将它转动为HTTPRequest.Request，然后使用HTTPClient将央求转发给贪图办事器。获得的反映信息会转动为HBResponse复返给诓骗。

运行诓骗，掀开网页掀开localhost:8080。咱们应该能看到咱们之前树立代理的httpbin.org网页信息

上头的树立不口角常理思。它会恭候央求十足加载，然后才将央求转发给贪图办事端。同理反映转发亦然需要恭候反映十足加载后才会转发。这裁汰了音问发送的后果，相同会导致央求占用遍及内存或者反映信息很大。

咱们不错通过流式传输请乞降反映负载来校正这小数。一朝咱们有了它的头部，就动手将央求发送到贪图办事，并在接收到主体部分时对其进行流式处理。访佛地，一朝咱们有了它的头，在另一个标的动手发送反映。摒除对完好央求或反映的恭候将栽培代理办事器的性能。

淌若客户端和代理之间的通讯以及代理和贪图办事之间的通讯以不同的速率运行，咱们仍然会碰到内存问题。淌若咱们接收数据的速率比处理数据的速率快，数据就会动手备份。为了幸免这种情况发生，咱们需要粗略施加背压以住手读取罕见的数据，直到咱们处理了填塞多的内存中的数据。有了这个，咱们不错将代理使用的内存量保握在最低截止。

流式传输央求负载是一个颠倒简短的经过。本色上，它简化了构造 HTTPClient.Request 的经过因为咱们不需要恭候央求十足加载。咱们怎样构造 HTTPClient.Request 主体将基于完好的 HBRequest 是否仍是在内存中。淌若咱们复返流央求，则会自动诓骗背压，因为 Hummingbird 办事器框架会为咱们履行此操作。

func ahcRequest(host: String， eventLoop: EventLoop) throws -> HTTPClient.Request {     let body: HTTPClient.Body?      switch self.body {     case .byteBuffer(let buffer):         body = buffer.map { .byteBuffer($0) }     case .stream(let stream):         body = .stream { writer in             // as we consume buffers from `HBRequest` we write them to             // the `HTTPClient.Request`.             return stream.consumeAll(on: eventLoop) { byteBuffer in                 writer.write(.byteBuffer(byteBuffer))             }         }     }     return try HTTPClient.Request(         url: host + self.uri.description，         method: self.method，         headers: self.headers，         body: body     ) } 

流式反映需要一个撤职 HTTPClientResponseDelegate 的class. 这将在 HTTPClient 反映可用时立即从反映中接收数据。反映正文是 ByteBuffers 形势. 咱们不错将这些 ByteBuffers 提供给 HBByteBufferStreamer. 咱们汇报的 HBResponse 是由这些流构造，而不是静态的 ByteBuffer。

淌若咱们将央求流与反映流代码聚合起来，咱们的最终的 apply 函数应该是这么的

func apply(to request: HBRequest， next: HBResponder) -> EventLoopFuture<HBResponse> {     do {         request.logger.info("Forwarding \(request.uri.path)")         // create request         let ahcRequest = try request.ahcRequest(host: target， eventLoop: request.eventLoop)         // create response body streamer. maxSize is the maximum size of object it can process         // maxStreamingBufferSize is the maximum size of data the streamer is allowed to have         // in memory at any one time         let streamer = HBByteBufferStreamer(eventLoop: request.eventLoop， maxSize: 2048*1024， maxStreamingBufferSize: 128*1024)         // HTTPClientResponseDelegate for streaming bytebuffers from AsyncHTTPClient         let delegate = StreamingResponseDelegate(on: request.eventLoop， streamer: streamer)         // execute request         _ = httpClient.execute(             request: ahcRequest，             delegate: delegate，             eventLoop: .delegateAndChannel(on: request.eventLoop)，             logger: request.logger         )         // when delegate receives head then signal completion         return delegate.responsePromise.futureResult     } catch {         return request.failure(error)     } } 

你会细密到在上头的代码中咱们不恭候httpClient.execute. 这是因为淌若咱们这么作念了，该函数将在陆续之前恭候所有反映主体在内存中。咱们但愿立即处理反映，因此咱们向奉求添加了一个promise: 一朝咱们收到头部信息，就贯通过保存头部笃定和流到HBResponse来竣事。EventLoopFuture这个 promise的是咱们从apply函数传回的。

我莫得在StreamingResponseDelegate这里包含代码，但您不错在完好的示例代码中[5]找到它。

该示例代码[6]可能在上头的基础上作念了部分修改。

咱们不错使用 HummingbirdCore 代替 Hummingbird 动作代理办事器。这将提供一些罕见的性能，因为它会删除罕见的代码层，但会捐躯生动性。添加任何罕见的路由或中间件需要作念更多的责任。我有只使用HummingbirdCore代理办事器的示例代码在这里[7]。

虽然，另一种选拔是使用 Vapor。我思在 Vapor 中的竣事看起来与上头神气的相称相似，应该不会太难。不外我会把它留给别东谈主。

[1]Hummingbird: https://github.com/hummingbird-project/hummingbird

[2]AsyncHTTPClient: https://github.com/swift-server/async-http-client

[3]Hummingbird模板技俩: https://github.com/hummingbird-project/template

[4]here: https://opticalaberration.com/2021/12/hummingbird-template.html

[5]示例代码中: https://github.com/hummingbird-project/hummingbird-examples/blob/main/proxy-server/Sources/App/Middleware/StreamingResponseDelegate.swift

[6]示例代码: https://github.com/hummingbird-project/hummingbird-examples/tree/main/proxy-server

[7]在这里: https://github.com/hummingbird-project/hummingbird-examples/tree/main/proxy-server-core