代理的核心功能可以用一句話概括：接受客戶端的請求，轉發到后端服務器，獲得應答之后返回給客戶端。
代理的功能有很多，事實上整個互聯網到處都充斥著代理服務器。如果所有的 HTTP 訪問都是客戶端和服務器端直接進行的話，我們的網絡不僅會變得緩慢，而且性能會大打折扣。
代理服務器根據不同的配置和使用，可能會有不同的功能，這些功能主要包括：
內容過濾：代理可以根據一定的規則限制某些請求的連接。比如有些公司會設置內部網絡無法訪問某些購物、游戲網站，或者學校的網絡不讓學生訪問色情暴力的網站等
節省成本：代理服務器可以作為緩存使用，對于某些資源只需要第一次訪問的時候去下載，以后代理直接把緩存的結果返回給客戶端，節約網絡帶寬的開銷
提高性能：通過代理服務器的緩存（比如 CDN）和負載均衡（比如 nginx lb）功能，服務器端可以加速請求的訪問，在更快的時間內返回結果）
增加安全性：公司可以在內網和外網之間通過代理進行轉發，這樣不僅對外隱藏了實現的細節，而且可以在代理層對爬蟲、病毒性請求進行過濾，保護內部服務
所有的這些功能的實現都依賴于代理的特性，它可以在客戶端和服務器端做一些事情，根據代理做的事情不同，它的角色和功能也就不同。那么，代理具體可以做哪些事情呢？比如：
修改 HTTP 請求：url、header、body
過濾請求：根據一定的規則丟棄、過濾請求
決定轉發到哪個后端（可以是靜態定義的，也可以是動態決定）
保存服務器的應答，后續的請求可以直接使用保存的應答
修改應答：對應答做一些格式的轉換，修改數據，甚至返回完全不一樣的應答數據
重試機制，如果后端服務器暫時無法響應，隔一段時間重試
……
正向代理和反向代理
代理可以分為正向代理和反向代理兩種。
正向代理需要客戶端來配置，一般來說我們會通過瀏覽器或者操作系統提供的工具或者界面來配置。這個時候，代理對客戶端不是透明的，客戶端需要知道代理的地址并且手動配置。配置了代理，瀏覽器在發送請求的時候會對報文做特殊的修改。
反向代理對客戶端是透明的，也就是說客戶端一般不知道代理的存在，認為自己是直接和服務器通信。我們大部分訪問的網站就是反向代理服務器，反向代理服務器會轉發到真正的服務器，一般在反向代理這一層實現負載均衡和高可用的功能。而且這里也可以看到，客戶端是不會知道真正服務器端的 ip 地址和端口的，這在一定程度上起到了安全保護的作用。
代理服務器怎么知道目的服務器的地址？
在反向代理中，代理服務器要轉發的服務器地址都是事先知道的（包括靜態配置和動態配置）。比如 使用 nginx 來配置負載均衡 。
而對于正向代理來說，客戶端可能訪問的服務器地址是無法事先知道的。因為HTTP 協議活動在應用層，它無法獲取網絡層（IP層）信息，那么該協議要有一個地方可以拿到這個信息。HTTP 中可能保存這個信息的地方有兩個：URL 和 header。默認情況下，HTTP 請求的 status line 有三部分組成：方法、uri 和協議版本，比如：
|
1
2
|
GET /index.html HTTP/1.0User-Agent: gohttp 1.0 |
如果客戶端（比如瀏覽器）知道自己在通過正向代理進行報文傳輸，那么它會在 status line 加上要訪問服務器的真實地址。這個時候發送的報文是：
|
1
2
|
GET http://www.marys-antiques.com/index.html HTTP/1.0User-Agent: gohttp 1.0 |
代理路徑
客戶端不管是通過代理服務器，還是直接訪問后端服務器對于最終的結果是沒有區別的，也就是說大多數情況下客戶端根本不關心它訪問的到底是什么，只需要（準確快速地）拿到想要的信息就夠了。但是有時候，我們還是希望知道請求到底在中間經歷了哪些代理，比如用來調試網絡異常，或者做數據統計，而 HTTP 協議也提供了響應的功能。
雖然 RFC 2616 定義了 Via 頭部字段來跟蹤 HTTP 請求經過的代理路徑，但在實際中用的更多的還是 X-Forwarded-For 字段， X-Forwarded-For 是 Squid 緩存代理服務軟件引入的，目前已經在規范化在 RFC 7239 文檔。
X-Forwarded-For 頭部格式也比較簡單，比如某個服務器接受到請求的對應頭部可能是：
X-Forwarded-For: client, proxy1, proxy2
對應的值有多個字段，每個字段代表中間的一個節點，它們之間由逗號和空格隔開，從左到右距離當前節點越來越近。
每個代理服務器會在 X-Forwarded-For 頭部填上前一個節點的 ip 地址，這個地址可以通過 TCP 請求的 remote address 獲取。為什么每個代理服務器不填寫自己的 ip 地址呢？有兩個原因，如果由代理服務器填寫自己的 ip 地址，那么代理可以很簡單地偽造這個地址，而上一個節點的 remote address 是根據 TCP 連接獲取的（如果不建立正確的 TCP 連接是無法進行 HTTP 通信的）；另外一個原因是如果由當前節點填寫 X-Forwarded-For ，那么很多情況客戶端無法判斷自己是否會通過代理的。
NOTE：
1、最終客戶端或者服務器端接受的請求， X-Forwarded-For 是沒有最鄰近節點的 ip 地址的，而這個地址可以通過 remote address 獲取
2、每個節點（不管是客戶端、代理服務器、真實服務器）都可以隨便更改 X-Forwarded-For 的值，因此這個字段只能作為參考
代理服務器實現
這個部分我們會介紹如何用 golang 來實現 HTTP 代理服務器，需要讀者了解一些 HTTP 服務器端編程的知識。
正向代理
按照我們之前介紹的代理原理，我們可以編寫出這樣的代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
package mainimport ( "fmt" "io" "net" "net/http" "strings")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 // this only does shallow copies of maps 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 :8080") http.Handle("/", &Pxy{}) http.ListenAndServe("0.0.0.0:8080", nil)} |
這段代碼比較直觀，只包含了最核心的代碼邏輯，完全按照最上面的代理圖例進行組織。一共分成幾個步驟：
1、代理接收到客戶端的請求，復制了原來的請求對象，并根據數據配置新請求的各種參數（添加上 X-Forward-For 頭部等）
2、把新請求發送到服務器端，并接收到服務器端返回的響應
3、代理服務器對響應做一些處理，然后返回給客戶端
上面的代碼運行之后，會在本地的 8080 端口啟動代理服務。修改瀏覽器的代理為 127.0.0.1：:8080 再訪問網站，可以驗證代理正常工作，也能看到它在終端打印出所有的請求信息。
雖然這段代碼非常簡短，但是你可以添加更多的邏輯實現非常有用的功能。比如在請求發送之前進行過濾，根據一定的規則直接阻止某些請求的訪問；或者對請求進行限流，某個客戶端在一定的時間里執行的請求有最大限額；統計請求的數據進行分析等等。
這個代理目前不支持 HTTPS 協議，因為它只提供了 HTTP 請求的轉發功能，并沒有處理證書和認證有關的內容。如果了解 HTTPS 協議的話，你會明白這種模式下是無法完成 HTTPS 握手的，雖然代理可以和真正的服務器建立連接（知道了對方的公鑰和證書），但是代理無法代表服務器和客戶端建立連接，因為代理服務器無法知道真正服務器的私鑰。
反向代理
編寫反向代理按照上面的思路當然沒有問題，只需要在第二步的時候，根據之前的配置修改 outReq 的 URL Host 地址可以了。不過 Golang 已經給我們提供了編寫代理的框架： httputil.ReverseProxy 。我們可以用非常簡短的代碼來實現自己的代理，而且內部的細節問題都已經被很好地處理了。
這部分我們會實現一個簡單的反向代理，它能夠對請求實現負載均衡，隨機地把請求發送給某些配置好的后端服務器。使用 httputil.ReverseProxy 編寫反向代理最重要的就是實現自己的 Director 對象，這是 GoDoc 對它的介紹：
Director must be a function which modifies the request into a new request to be sent using Transport. Its response is then copied back to the original client unmodified. Director must not access the provided Request after returning.
簡單翻譯的話， Director 是一個函數，它接受一個請求作為參數，然后對其進行修改。修改后的請求會實際發送給服務器端，因此我們編寫自己的 Director 函數，每次把請求的 Scheme 和 Host 修改成某個后端服務器的地址，就能實現負載均衡的效果（其實上面的正向代理也可以通過相同的方法實現）。看代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
package mainimport ( "log" "math/rand" "net/http" "net/http/httputil" "net/url")func NewMultipleHostsReverseProxy(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}}func main() { proxy := NewMultipleHostsReverseProxy([]*url.URL{ { Scheme: "http", Host: "localhost:9091", }, { Scheme: "http", Host: "localhost:9092", }, }) log.Fatal(http.ListenAndServe(":9090", proxy))} |
我們讓代理監聽在 9090 端口，在后端啟動兩個返回不同響應的服務器分別監聽在 9091 和 9092 端口，通過 curl 訪問，可以看到多次請求會返回不同的結果。
|
1
2
3
4
|
? curl http://127.0.0.1:9090116064a9eb83? curl http://127.0.0.1:90908f7ccc11718f |
同樣的，這段代碼也只是一個 demo，存在著很多問題，比如沒有錯誤處理機制，如果后端某個服務器掛了，代理會返回 502 錯誤，更好的做法是把請求轉發到另外的可用服務器。當然也可以添加更多的特性讓它更好用，比如動態地添加后端服務器列表；根據后端服務器的負載情況進行負載轉發等等。
補充：golang 超簡單實現反向代理（nginx 端口轉發 Proxy）
100行你就可以做到類似nginx帶自動更新的端口轉發功能
總共就2個文件，一個main（總行數128行），一個配置文件
main：
里面的json解析和log可以忽略
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
package main import ( "github.com/weimingjue/json" utils2 "goProxy/utils" "goService/utils" "io/ioutil" "net" "net/http" "net/http/httputil" "net/url" "os" "strings" "sync" "time") var ( projectDir, _ = os.Getwd() fileName = projectDir + "/domain.config" readFileTime int64 = 0 //讀取文件的時間 fileChangedTime int64 = 0 //文件修改時間 domainData [][]string //[{***.gq,8080,http://127.0.0.1:8080/}] duPeiZhiSuo sync.Mutex //讀配置鎖) // 獲取反向代理域名func getProxyUrl(reqDomain string) string { checkFile() for _, dms := range domainData { if strings.Index(reqDomain, dms[0]) >= 0 { return dms[2] } } return domainData[0][2]} //讀取配置文件//域名:端口號，未知域名默認用第一個func checkFile() { nowTime := time.Now().Unix() if nowTime-readFileTime < 300 { return } //每5分鐘判斷文件是否修改 domainFile, _ := os.OpenFile(fileName, os.O_WRONLY|os.O_APPEND, 0) info, _ := domainFile.Stat() if info.ModTime().Unix() == fileChangedTime { return } duPeiZhiSuo.Lock() defer duPeiZhiSuo.Unlock() domainFile, _ = os.OpenFile(fileName, os.O_WRONLY|os.O_APPEND, 0) //加鎖再來一遍，防止重入 info, _ = domainFile.Stat() changedTime := info.ModTime().Unix() if changedTime == fileChangedTime { return } //文件改變 //重置數據 readFileTime = nowTime fileChangedTime = changedTime domainData = [][]string{} bytes, _ := ioutil.ReadFile(fileName) split := strings.Split(string(bytes), "\n") for _, domainInfo := range split { dLen := len(domainInfo) if dLen < 8 || dLen > 20 { //忽略錯誤信息 continue } domainItems := strings.Split(domainInfo, ":") if len(domainItems) != 2 || len(domainItems[0]) < 3 || len(domainItems[1]) < 2 { continue } if utils.EndWidth(domainItems[1], "/") { domainItems = append(domainItems, "http://127.0.0.1:"+domainItems[1]) } else { domainItems = append(domainItems, "http://127.0.0.1:"+domainItems[1]+"/") } domainData = append(domainData, domainItems) } domainSt, _ := json.Marshal(domainData) utils2.MyLogProxyI("配置已修改：" + string(domainSt))} //獲取主機名func getHost(req *http.Request) string { if req.Host != "" { if hostPart, _, err := net.SplitHostPort(req.Host); err == nil { return hostPart } return req.Host } return "localhost"} func handleRequestAndRedirect(res http.ResponseWriter, req *http.Request) { host := getHost(req) proxyUrl := getProxyUrl(host) url2, _ := url.Parse(proxyUrl) utils2.MyLogProxyI("請求域名：" + host + "，轉到：" + proxyUrl) // create the reverse proxy proxy := httputil.NewSingleHostReverseProxy(url2) // Update the headers to allow for SSL redirection req.URL.Host = url2.Host req.URL.Scheme = url2.Scheme req.Header.Set("X-Forwarded-Host", req.Header.Get("Host")) req.Host = url2.Host // Note that ServeHttp is non blocking and uses a go routine under the hood proxy.ServeHTTP(res, req)} func main() { http.HandleFunc("/", handleRequestAndRedirect) if err := http.ListenAndServe(":80", nil); err != nil { utils.MyLogE("Proxy監聽80端口錯誤：" + err.Error()) panic(err) }} |
domain.config：
***為自己的域名，":"后面是需要轉發的端口，不用寫http://，任何地方都不能有空格
|
1
2
|
wang.gq:8080***.aa:8081/ |
代碼寫的是相對目錄請到當前目錄執行"go run main.go"，愉快的轉發從現在開始
以上為個人經驗，希望能給大家一個參考，也希望大家多多支持服務器之家。如有錯誤或未考慮完全的地方，望不吝賜教。
原文鏈接：https://blog.csdn.net/mengxinghuiku/article/details/65448600
