网络代理
什么是网络代理？
- 用户通过代理请求信息
- 请求通过代理完成转发到达目标服务器
- 目标服务器响应过后再通过网络代理回传给用户
网络代理与网络转发的区别
- 网络代理，用户不直接连接目标服务器，而是连接代理服务器，由代理服务器去连接目标服务器。获取到数据后返回到代理服务器，再返回给原请求服务器
- 网络转发，是原服务器直接连接目标服务器，由路由器对报文进行转发
类型
网络代理分为正向代理和反向代理两个类型
- 正向代理 是一种客户端的代理技术，帮助客户端访问无法访问的服务资源，可以隐藏用户的真是IP。 比如： 浏览器web代理、VPN等
- 反向代理 是一种服务端的代理技术，帮助服务端做负载均衡、缓存、提供安全校验等，可以隐藏服务器真是IP。 比如LVS技术、nginx proxy_pass等
正向代理
- 代理接受客户端请求，复制原请求对象，并根据数据配置新请求各种参数
- 把新请求发送到真实服务端，并接收服务器端返回
- 代理服务器对响应返回做一些处理，然后返回给客户端
代码实例
// 定义http.Handler接口实现
type Pxy struct{}
func (p *Pxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
fmt.Printf("Received request %s %s %s\n", req.Method, req.Host, req.RemoteAddr)
transport := http.DefaultTransport
// step 1，浅拷贝对象，然后就再新增属性数据
outReq := new(http.Request)
*outReq = *req
// 分隔请求ip与端口
if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
if prior, ok := outReq.Header["X-Forwarded-For"]; ok {
clientIP = strings.Join(prior, ", ") + ", " + clientIP
}
outReq.Header.Set("X-Forwarded-For", clientIP)
}
// step 2, 请求下游
res, err := transport.RoundTrip(outReq)
if err != nil {
rw.WriteHeader(http.StatusBadGateway)
return
}
// step 3, 把下游请求内容返回给上游
for key, value := range res.Header {
for _, v := range value {
rw.Header().Add(key, v)
}
}
rw.WriteHeader(res.StatusCode)
io.Copy(rw, res.Body)
res.Body.Close()
}
func main() {
fmt.Println("Serve on :8081")
http.Handle("/", &Pxy{})
http.ListenAndServe("0.0.0.0:8081", nil)
}
反向代理
反向代理分为真实服务器和代理服务器两部分
反向代理种类有很多，这里介绍下最简单的HTTP代理
真实服务器
func main() {
rs1 := &RealServer{Addr: "127.0.0.1:2003"}
rs1.Run()
rs2 := &RealServer{Addr: "127.0.0.1:2004"}
rs2.Run()
//监听关闭信号
quit := make(chan os.Signal)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
}
type RealServer struct {
Addr string
}
func (r *RealServer) Run() {
log.Println("Starting httpserver at " + r.Addr)
mux := http.NewServeMux()
mux.HandleFunc("/", r.HelloHandler)
mux.HandleFunc("/base/error", r.ErrorHandler)
mux.HandleFunc("/test_http_string/test_http_string/aaa", r.TimeoutHandler)
server := &http.Server{
Addr: r.Addr,
WriteTimeout: time.Second * 3,
Handler: mux,
}
go func() {
log.Fatal(server.ListenAndServe())
}()
}
func (r *RealServer) HelloHandler(w http.ResponseWriter, req *http.Request) {
//127.0.0.1:8008/abc?sdsdsa=11
//r.Addr=127.0.0.1:8008
//req.URL.Path=/abc
//fmt.Println(req.Host)
upath := fmt.Sprintf("http://%s%s\n", r.Addr, req.URL.Path)
realIP := fmt.Sprintf("RemoteAddr=%s,X-Forwarded-For=%v,X-Real-Ip=%v\n", req.RemoteAddr, req.Header.Get("X-Forwarded-For"), req.Header.Get("X-Real-Ip"))
header:=fmt.Sprintf("headers =%v\n",req.Header)
io.WriteString(w, upath)
io.WriteString(w, realIP)
io.WriteString(w, header)
}
func (r *RealServer) ErrorHandler(w http.ResponseWriter, req *http.Request) {
upath := "error handler"
w.WriteHeader(500)
io.WriteString(w, upath)
}
func (r *RealServer) TimeoutHandler(w http.ResponseWriter, req *http.Request) {
time.Sleep(6*time.Second)
upath := "timeout handler"
w.WriteHeader(200)
io.WriteString(w, upath)
}
代理服务器配置
var (
proxy_addr = "http://127.0.0.1:2003"
port = "2002"
)
func handler(w http.ResponseWriter, r *http.Request) {
//step 1 解析代理地址，并更改请求体的协议和主机
proxy, err := url.Parse(proxy_addr)
r.URL.Scheme = proxy.Scheme
r.URL.Host = proxy.Host
//step 2 请求下游
transport := http.DefaultTransport
resp, err := transport.RoundTrip(r)
if err != nil {
log.Print(err)
return
}
//step 3 把下游请求内容返回给上游
for k, vv := range resp.Header {
for _, v := range vv {
w.Header().Add(k, v)
}
}
defer resp.Body.Close()
bufio.NewReader(resp.Body).WriteTo(w)
}
func main() {
http.HandleFunc("/", handler)
log.Println("Start serving on port " + port)
err := http.ListenAndServe(":"+port, nil)
if err != nil {
log.Fatal(err)
}
}