Go | Go 结合 Consul 实现动态反向代理
本文内容纲要：
-Go结合Consul实现动态反向代理
-反向代理
-实现逻辑
-Go语言实现
-原生代码
-httputil.ReverseProxy工具实现
-接入consul实现动态代理
-参考
Go结合Consul实现动态反向代理
代理的核心功能可以用一句话概括：接受客户端的请求，转发到后端服务器，获得应答之后返回给客户端。
TableofContents
-
反向代理
-
实现逻辑
-
Go语言实现
- 原生代码
- httputil.ReverseProxy工具实现
-
接入consul实现动态代理
-
参考
反向代理
反向代理（ReverseProxy）实际运行方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个服务器。
实现逻辑
根据代理的描述一共分成几个步骤：
- 代理接收到客户端的请求，复制了原来的请求对象
- 根据一些规则，修改新请求的请求指向
- 把新请求发送到根据服务器端，并接收到服务器端返回的响应
- 将上一步的响应根据需求处理一下，然后返回给客户端
Go语言实现
原生代码
因为要接收并转发http请求，所以要实现http.Handler
typeOriginReverseProxystruct{
servers[]*url.URL
}
funcNewOriginReverseProxy(targets[]*url.URL)*OriginReverseProxy{
return&OriginReverseProxy{
servers:targets,
}
}
//实现http.Handler,用于接收所有的请求
func(proxy*OriginReverseProxy)ServeHTTP(rwhttp.ResponseWriter,req*http.Request){
//1.复制了原来的请求对象
r2:=clone(req)
//2.修改请求的地址，换为对应的服务器地址
target:=proxy.servers[rand.Int()%len(proxy.servers)]
r2.URL.Scheme=target.Scheme
r2.URL.Host=target.Host
//3.发送复制的新请求
transport:=http.DefaultTransport
res,err:=transport.RoundTrip(r2)
//4。处理响应
iferr!=nil{
rw.WriteHeader(http.StatusBadGateway)
return
}
forkey,value:=rangeres.Header{
for_,v:=rangevalue{
rw.Header().Add(key,v)
}
}
rw.WriteHeader(res.StatusCode)
io.Copy(rw,res.Body)
res.Body.Close()
}
//复制原请求，生成新的请求
funcclone(req*http.Request)*http.Request{
r2:=new(http.Request)
*r2=*req
r2.URL=cloneURL(req.URL)
ifreq.Header!=nil{
r2.Header=req.Header.Clone()
}
ifreq.Trailer!=nil{
r2.Trailer=req.Trailer.Clone()
}
ifs:=req.TransferEncoding;s!=nil{
s2:=make([]string,len(s))
copy(s2,s)
r2.TransferEncoding=s2
}
r2.Form=cloneURLValues(req.Form)
r2.PostForm=cloneURLValues(req.PostForm)
returnr2
}
funccloneURLValues(vurl.Values)url.Values{
ifv==nil{
returnnil
}
returnurl.Values(http.Header(v).Clone())
}
funccloneURL(u*url.URL)*url.URL{
ifu==nil{
returnnil
}
u2:=new(url.URL)
*u2=*u
ifu.User!=nil{
u2.User=new(url.Userinfo)
*u2.User=*u.User
}
returnu2
}
测试
//先用gin起一个web项目，方便转发
funcTestGin(t*testing.T){
r:=gin.Default()
r.GET("/ping",func(c*gin.Context){
c.JSON(200,gin.H{
"message":"pong",
})
})
r.Run(":9091")//listenandserveon0.0.0.0:9091
}
funcmain(){
proxy:=proxy.NewOriginReverseProxy([]*url.URL{
{
Scheme:"http",
Host:"localhost:9091",
},
})
http.ListenAndServe(":19090",proxy)
}
请求http://127.0.0.1:19090/ping返回{"message":"pong"}
httputil.ReverseProxy工具实现
在上面的例子中，我们自己实现了请求的接收、复制、转发和处理。自己写的代码还算凑合吧。
从上面的示例中，其实我们主要关心的是第二步:修改请求的地址，换为对应的服务器地址,其余的逻辑都是通用的，还好官方已经帮我们处理了重复逻辑，那我们看看官方是怎么实现的
在httputil.ReverseProxy源码中，可以看出，通过自定义Director方法就可以在原请求复制后，新请求转发出之前对复制出的新请求进行修改，这里就是我们真正改动的地方，当然如果有其他定制需求，可以通过自定义ModifyResponse实现对响应的修改，自定义ErrorHandler来处理异常
typeReverseProxystruct{
//Directormustbeafunctionwhichmodifies
//therequestintoanewrequesttobesent
//usingTransport.Itsresponseisthencopied
//backtotheoriginalclientunmodified.
//DirectormustnotaccesstheprovidedRequest
//afterreturning.
Directorfunc(*http.Request)
Transporthttp.RoundTripper
FlushIntervaltime.Duration
ErrorLog*log.Logger
BufferPoolBufferPool
ModifyResponsefunc(*http.Response)error
ErrorHandlerfunc(http.ResponseWriter,*http.Request,error)
}
这里我们通过自定义Director来修改请求地址
funcNewMultipleHostsReverseProxy(targets[]*url.URL)*httputil.ReverseProxy{
director:=func(req*http.Request){
target:=targets[rand.Int()%len(targets)]
req.URL.Scheme=target.Scheme
req.URL.Host=target.Host
req.URL.Path=target.Path
}
return&httputil.ReverseProxy{Director:director}
}
测试
gin的项目还是要启动的，这里不在赘叙
funcTestMultipleHostsReverseProxy(t*testing.T){
proxy:=proxy.NewMultipleHostsReverseProxy([]*url.URL{
{
Scheme:"http",
Host:"localhost:9091",
},
})
http.ListenAndServe(":9090",proxy)
}
接入consul实现动态代理
在前面的一篇文章中讲了如何用Go实现Consul的服务发现,如果要结合consul实现动态代理，需要考虑如何将请求的地址和对应的服务对应上。这里需要在原理的基础上加上一下功能：
- 根据请求地址找到对应的服务
- 根据服务找到对应的示例
针对第一步先实现最简单的，就以请求地址开头为规则
typeLoadBalanceRouteinterface{
ObtainInstance(pathstring)*url.URL
}
typeRoutestruct{
Pathstring
ServiceNamestring
}
typeDiscoveryLoadBalanceRoutestruct{
DiscoveryClientDiscoveryClient
Routes[]Route
}
func(dDiscoveryLoadBalanceRoute)ObtainInstance(pathstring)*url.URL{
for_,route:=ranged.Routes{
ifstrings.Index(path,route.Path)==0{
instances,_:=d.DiscoveryClient.GetInstances(route.ServiceName)
instance:=instances[rand.Int()%len(instances)]
scheme:="http"
return&url.URL{
Scheme:scheme,
Host:instance.GetHost(),
}
}
}
returnnil
}
funcNewLoadBalanceReverseProxy(lbLoadBalanceRoute)*httputil.ReverseProxy{
director:=func(req*http.Request){
target:=lb.ObtainInstance(req.URL.Path)
req.URL.Scheme=target.Scheme
req.URL.Host=target.Host
}
return&httputil.ReverseProxy{Director:director}
}
测试
funcmain(){
registry,_:=proxy.NewConsulServiceRegistry("127.0.0.1",8500,"")
reverseProxy:=proxy.NewLoadBalanceReverseProxy(&proxy.DiscoveryLoadBalanceRoute{
DiscoveryClient:registry,
Routes:[]proxy.Route{
{
Path:"abc",
ServiceName:"abc",
},
},
})
http.ListenAndServe(":19090",reverseProxy)
}
本文内容总结：Go结合Consul实现动态反向代理，反向代理，实现逻辑，Go语言实现，原生代码，httputil.ReverseProxy工具实现，接入consul实现动态代理
原文链接：https://www.cnblogs.com/zyndev/p/14454891.html