Go HTTP 框架之 Hertz —— 通过 reverseproxy 进行反向代理实战

Go HTTP 框架之 Hertz —— 通过 reverseproxy 进行反向代理实战反向代理在计算机网络中是代理服务器的一种。 Hertz 是一个超大规模的企业级微服务 HTTP 框架,具有高易用性、易扩展、低时延等特点。

Hertz

Hertz 是一个超大规模的企业级微服务 HTTP 框架,具有高易用性、易扩展、低时延等特点。

Hertz 默认使用自研的高性能网络库 Netpoll,在一些特殊场景中,相较于 go net,Hertz 在 QPS、时延上均具有一定优势。

在内部实践中,某些典型服务,如框架占比较高的服务、网关等服务,迁移 Hertz 后相比 Gin 框架,资源使用显著减少,CPU 使用率随流量大小降低 30%—60%

关于 Hertz 更多的信息可移步至 cloudwego/hertz

反向代理

反向代理在计算机网络中是代理服务器的一种。

服务器根据客户端的请求,从其关系的一组或多组后端服务器(如 Web 服务器)上获取资源,然后再将这些资源返回给客户端,客户端只会得知反向代理的 IP 地址,而不知道在代理服务器后面的服务器集群的存在。

Hertz 反向代理实战

在 Hertz 中使用反向代理需要拉取社区提供的 reverseproxy 拓展。

$ go get github.com/hertz-contrib/reverseproxy

基本使用

package main

import (
        "context"

        "github.com/cloudwego/hertz/pkg/app"
        "github.com/cloudwego/hertz/pkg/app/server"
        "github.com/cloudwego/hertz/pkg/common/utils"
        "github.com/hertz-contrib/reverseproxy"
)

func main() {
        h := server.Default(server.WithHostPorts("127.0.0.1:8000"))
        proxy, err := reverseproxy.NewSingleHostReverseProxy("http://127.0.0.1:8000/proxy")
        if err != nil {
                panic(err)
        }
        h.GET("/proxy/backend", func(cc context.Context, c *app.RequestContext) {
                c.JSON(200, utils.H{
                        "msg": "proxy success!!",
                })
        })
        h.GET("/backend", proxy.ServeHTTP)
        h.Spin()
}

我们通过 NewSingleHostReverseProxy 函数设置了反向代理的目标路径 /proxy 。接下来注册路由的路径为反向代理目标路径的子路径 /proxy/backend ,最后通过注册 /backend 映射反向代理服务 proxy.ServeHTTP 。这样我们通过 GET 方法访问 /backend 时就会访问到 /proxy/backend 中的内容。

curl 127.0.0.1:8000/backend

{"msg":"proxy success!!"}

自定义配置

当然,拓展不只是能够实现简单的反向代理,在 reverseproxy 拓展中提供了许多可以自定义的可选项。

方法 描述
SetDirector 用于指定 protocol.Request
SetClient 用于指定转发的客户端
SetModifyResponse 用于指定响应修改方法
SetErrorHandler 用于指定处理到达后台的错误或来自 modifyResponse 的错误

SetDirector & SetClient

我们通过实现一个简单的服务注册发现来进实践使用 SetDirectorSetClient

Server
package main

import (
        "context"

        "github.com/cloudwego/hertz/pkg/app"
        "github.com/cloudwego/hertz/pkg/app/server"
        "github.com/cloudwego/hertz/pkg/app/server/registry"
        "github.com/cloudwego/hertz/pkg/common/utils"
        "github.com/cloudwego/hertz/pkg/protocol/consts"
        "github.com/hertz-contrib/registry/nacos"
)

func main() {
        addr := "127.0.0.1:8000"
        r, _ := nacos.NewDefaultNacosRegistry()
        h := server.Default(
                server.WithHostPorts(addr),
                server.WithRegistry(r, &registry.Info{
                        ServiceName: "demo.hertz-contrib.reverseproxy",
                        Addr:        utils.NewNetAddr("tcp", addr),
                        Weight:      10,
                }),
        )
        h.GET("/backend", func(cc context.Context, c *app.RequestContext) {
                c.JSON(consts.StatusOK, utils.H{"ping": "pong"})
        })
        h.Spin()
}

这里使用了 hertz-contrib/registry 拓展中 server 端的示例代码,由于这并不是本文的主要内容所以不做展开,关于更多信息可以去到 registry 库中。

Client
package main

import (
        "github.com/cloudwego/hertz/pkg/app/client"
        "github.com/cloudwego/hertz/pkg/app/middlewares/client/sd"
        "github.com/cloudwego/hertz/pkg/app/server"
        "github.com/cloudwego/hertz/pkg/common/config"
        "github.com/cloudwego/hertz/pkg/protocol"
        "github.com/hertz-contrib/registry/nacos"
        "github.com/hertz-contrib/reverseproxy"
)

func main() {
        cli, err := client.NewClient()
        if err != nil {
                panic(err)
        }
        r, err := nacos.NewDefaultNacosResolver()
        if err != nil {
                panic(err)
        }
        cli.Use(sd.Discovery(r))
        h := server.New(server.WithHostPorts(":8741"))
        proxy, _ := reverseproxy.NewSingleHostReverseProxy("http://demo.hertz-contrib.reverseproxy")
        proxy.SetClient(cli)
        proxy.SetDirector(func(req *protocol.Request) {
                req.SetRequestURI(string(reverseproxy.JoinURLPath(req, proxy.Target)))
                req.Header.SetHostBytes(req.URI().Host())
                req.Options().Apply([]config.RequestOption{config.WithSD(true)})
        })
        h.GET("/backend", proxy.ServeHTTP)
        h.Spin()
}

Client 部分中我们在服务发现使用了反向代理。首先通过 SetClient 将使用了服务发现中间件的客户端指定为我们的转发客户端,再使用 SetDirector 指定了我们的 protocol.Request ,并在新的 Request 中配置了服务发现的使用。

SetModifyResponse & SetErrorHandler

SetModifyResponseSetErrorHandler 分别设置来自后端的响应以及到达后台错误的处理。 SetModifyResponse 实则是在设置反向代理拓展中的 modifyResponse ,如果后端返回任意响应,不管状态码是什么,这个方法将会被调用。如果 modifyResponse 方法返回一个错误,errorHandler 方法将会使用错误做入参被调用。

SetModifyResponse
package main

import (
        "github.com/cloudwego/hertz/pkg/app/server"
        "github.com/cloudwego/hertz/pkg/protocol"
        "github.com/hertz-contrib/reverseproxy"
)

func main() {
        h := server.Default(server.WithHostPorts("127.0.0.1:8000"))
        // modify response
        proxy, _ := reverseproxy.NewSingleHostReverseProxy("http://127.0.0.1:8000/proxy")
        proxy.SetModifyResponse(func(resp *protocol.Response) error {
                resp.SetStatusCode(200)
                resp.SetBodyRaw([]byte("change response success"))
                return nil
        })
        h.GET("/modifyResponse", proxy.ServeHTTP)

        h.Spin()
}

在这里通过 SetModifyResponse 修改 modifyResponse 进以改变响应的处理内容。

测试

curl 127.0.0.1:8000/modifyResponse

change response success
SetErrorHandler
package main

import (
        "context"

        "github.com/cloudwego/hertz/pkg/app"
        "github.com/cloudwego/hertz/pkg/app/server"
        "github.com/cloudwego/hertz/pkg/common/utils"
        "github.com/hertz-contrib/reverseproxy"
)

func main() {
        h := server.Default(server.WithHostPorts("127.0.0.1:8002"))
        proxy, err := reverseproxy.NewSingleHostReverseProxy("http://127.0.0.1:8000/proxy")
        if err != nil {
                panic(err)
        }
        proxy.SetErrorHandler(func(c *app.RequestContext, err error) {
                c.Response.SetStatusCode(404)
                c.String(404, "fake 404 not found")
        })

        h.GET("/proxy/backend", func(cc context.Context, c *app.RequestContext) {
                c.JSON(200, utils.H{
                        "msg": "proxy success!!",
                })
        })
        h.GET("/backend", proxy.ServeHTTP)
        h.Spin()
}

我们通过 SetErrorHandler 指定如何处理到达后台的错误,当有错误到达后台或有来自 modifyResponse 的错误时就会运行指定的处理逻辑。

测试

curl 127.0.0.1:8002/backend

fake 404 not found

中间件使用

除了基本使用外,Hertz 反向代理还支持在中间件中使用。

package main

import (
        "context"
        "github.com/cloudwego/hertz/pkg/app"
        "github.com/cloudwego/hertz/pkg/app/server"
        "github.com/cloudwego/hertz/pkg/common/utils"
        "github.com/hertz-contrib/reverseproxy"
)

func main() {
        r := server.Default(server.WithHostPorts("127.0.0.1:9998"))
        r2 := server.Default(server.WithHostPorts("127.0.0.1:9997"))

        proxy, err := reverseproxy.NewSingleHostReverseProxy("http://127.0.0.1:9997")
        if err != nil {
                panic(err)
        }

        r.Use(func(c context.Context, ctx *app.RequestContext) {
                if ctx.Query("country") == "cn" {
                        proxy.ServeHTTP(c, ctx)
                        ctx.Response.Header.Set("key", "value")
                        ctx.Abort()
                } else {
                        ctx.Next(c)
                }
        })

        r.GET("/backend", func(c context.Context, ctx *app.RequestContext) {
                ctx.JSON(200, utils.H{
                        "message": "pong1",
                })
        })

        r2.GET("/backend", func(c context.Context, ctx *app.RequestContext) {
                ctx.JSON(200, utils.H{
                        "message": "pong2",
                })
        })

        go r.Spin()
        r2.Spin()
}

在这段实例代码中,首先初始化了两个 Hertz 实例,接着使用 NewSingleHostReverseProxy 设置反向代理目标为 9997 端口,在最后对两个实例分别注册了两个路径相同的路由。

测试1

curl 127.0.0.1:9997/backend

{"message":"pong2"}
curl 127.0.0.1:9998/backend

{"message":"pong1"}

这段代码的主要部分为中间件使用部分,我们通过 Use 使用中间件,在中间件逻辑中,当 ctx.Query("country") == "cn" 逻辑成立时调用 proxy.ServeHTTP(c, ctx) 使用反向代理,此时再通过实例 r 请求 /backend 时就会请求到反向代理目标 9997 端口中的内容。

测试2

curl 127.0.0.1:9998/backend?country=cn

{"message":"pong2"}

注意项

  • NewSingleHostReverseProxy 函数如果没有设置 config.ClientOption 将会使用默认的全局 client.Client 实例, 如果设置了 config.ClientOption 将会初始化一个 client.Client 实例。 如果你需要共享一个 client.Client 实例,可以使用 ReverseProxy.SetClient 来设置。
  • 反向代理会重置响应头,如果在请求之前修改了响应头将不会生效,这与标准库的行为不一致。

参考

今天的文章Go HTTP 框架之 Hertz —— 通过 reverseproxy 进行反向代理实战分享到此就结束了,感谢您的阅读。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/19123.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注