深入浅出：反向代理从原理应用到代码示例

DngGentle

2025.02.15

阅读时间 4 分钟

首页 / 系统设计 / 深入浅出：反向代理从原理应用到代码示例

深入浅出：反向代理从原理应用到代码示例

0.说明

本文为深入浅出反向代理—从原理应用到代码示例视频的整理稿，略有修补。第六部分开始为代码示例，示例具体代码库在sodaGinx，有时间我完善一下示例。

1. 代理与正向代理

在网络通信中，客户端（例如你的电脑）与服务器之间直接进行交互。但有时，这种直接交互可能因为各种原因受阻，比如服务器设置了地域限制，只允许特定地区的 IP 地址访问。这时，就需要“代理”介入。

正向代理的基本原理：

客户端不直接访问目标服务器（例如 Google 服务器）。
客户端将请求发送给一个代理服务器（例如位于美国的服务器）。
代理服务器代表客户端向目标服务器发送请求。
目标服务器将响应返回给代理服务器。
代理服务器再将响应转发给客户端。

这样，对于目标服务器而言，它只知道与代理服务器通信，而不知道真正的客户端是谁。通过多层代理，甚至可以实现匿名性，Tor 网络就是基于这个原理。正向代理的关键在于，客户端知道自己要访问的目标服务器是谁。

正向代理的理论基础：

HTTP 规范：《HTTP 权威指南》第六章详细阐述了代理的概念。代理服务器作为中间实体，可以处理各种 HTTP 请求和响应。
匿名性：正向代理可以隐藏客户端的真实 IP 地址，提高客户端的匿名性。多层代理（如 Tor 网络）通过随机选择路径，进一步增强了这种匿名性。
访问控制：正向代理可以绕过某些网络限制或防火墙，访问原本无法访问的资源。

2. 反向代理：概念与基本原理

反向代理与正向代理不同，它站在服务器的角度考虑问题。假设你是一个网站提供者，提供两种服务：查询油价和查询蛋糕价格。

随着用户访问量的增加，单一服务器可能无法处理所有请求。这时，你可以引入一个“反向代理”（也可以称为网关）来分流。

反向代理的基本工作流程：

用户向你的网站发送请求。
反向代理服务器接收请求。
根据请求内容（例如查询油价还是蛋糕价格），反向代理将请求转发到相应的后端服务器。
后端服务器处理请求，并将结果返回给反向代理。
反向代理再将结果返回给用户。

反向代理可以根据地理位置（例如北方用户和南方用户）或请求类型（查询油价或蛋糕价格）来分配请求。对用户而言，他们只需要与网站的主页交互，无需关心具体是哪台服务器处理了请求。

反向代理的理论基础：

网关：反向代理在概念上类似于网关，充当着客户端和后端服务器之间的桥梁。
HTTP 路由：反向代理根据 HTTP 请求的 URL、头部信息或其他特征，将请求路由到不同的后端服务器。
负载均衡算法：反向代理使用各种算法（如轮询、最少连接、IP 哈希等）来决定将请求分配给哪个后端服务器。

3. 反向代理的核心功能与优势

反向代理不仅仅是简单的转发请求，它还提供了许多关键功能：

3.1 负载均衡 (Load Balancing)

负载均衡是反向代理最基本也是最重要的功能。它将用户请求分摊到多个后端服务器上，避免单一服务器过载。

负载均衡的实现：

轮询（Round Robin）：按顺序将请求依次分配给后端服务器。
最少连接（Least Connections）：将请求分配给当前连接数最少的服务器。
IP 哈希（IP Hash）：根据客户端 IP 地址的哈希值，将请求分配给固定的服务器，确保来自同一客户端的请求始终由同一服务器处理。
加权轮询/加权最少连接: 根据服务器性能配置不同的权重.

3.2 高可用性 (High Availability)

通过负载均衡，即使某个后端服务器宕机，反向代理可以将请求自动转发到其他正常运行的服务器，保证服务的持续可用性。

高可用性的实现：

健康检查（Health Check）：反向代理定期检查后端服务器的健康状态，如果发现服务器无响应，则将其从可用服务器列表中移除。
故障转移（Failover）：当主服务器宕机时，反向代理自动将请求切换到备用服务器。

3.3 安全性 (Security)

反向代理可以隐藏后端服务器的真实 IP 地址和网络结构，增加攻击者直接攻击后端服务器的难度。

安全性的实现：

隐藏内部结构：攻击者只能看到反向代理服务器，无法直接访问后端服务器。
防火墙隔离：将后端服务器部署在内网，只允许反向代理服务器访问，形成隔离区域。
防止 DDoS 攻击：反向代理可以作为第一道防线，过滤恶意流量，保护后端服务器。

3.4 SSL 终端 (SSL Termination)

反向代理可以处理 SSL/TLS 加密和解密，减轻后端服务器的负担，并简化 SSL 证书管理。

SSL 终端的实现：

集中管理：只需在反向代理服务器上配置 SSL 证书，无需在每个后端服务器上分别配置。
性能优化：SSL 加密和解密是计算密集型操作，由反向代理处理可以提高后端服务器的性能。
简化配置：降低了配置和维护 SSL 的复杂性。

3.5 缓存 (Caching)

反向代理可以缓存静态内容（例如图片、CSS、JavaScript 文件），减少对后端服务器的请求，提高响应速度。

缓存的实现：

静态内容缓存：将不经常变化的静态资源存储在反向代理服务器上，用户请求时直接从缓存返回。
动态内容缓存：对于某些动态内容，也可以设置一定的缓存时间，减少对后端服务器的频繁请求。

3.6 API 网关与微服务架构

在微服务架构中，反向代理可以用作 API 网关，统一管理和路由不同微服务之间的请求。

API 网关的功能：

请求聚合：将来自客户端的多个请求聚合为一个请求，发送给后端服务。
服务发现：动态发现新的微服务实例，并将其添加到路由规则中。
统一入口：为所有微服务提供一个统一的访问入口，简化客户端的调用逻辑。
认证与授权：在 API 网关层进行统一的认证和授权，保护后端微服务。
限流与熔断：防止过多的请求涌入后端服务，提高系统的稳定性。

4. 报文处理

反向代理处理报文的方式非常高效。客户端将所有数据发送给反向代理服务器，后者解析请求，根据预定义的规则（例如 URL 路径、请求头部）将请求转发到合适的后端服务器。

5. 反向代理的实现与应用

常见的反向代理软件包括 Nginx、Apache HTTP Server、HAProxy 等。

对于开发和测试，也可以使用轻量级的工具或自己编写简单的反向代理程序。

小结

反向代理在现代软件架构中扮演着至关重要的角色。它通过负载均衡、高可用性、安全性、SSL 终端、缓存和 API 网关等功能，提高了系统的性能、可靠性、安全性和可维护性。正向代理隐藏客户端，反向代理隐藏服务端。理解反向代理的原理和应用，对于构建高性能、高可用的 Web 应用至关重要。

6. 反向代理的代码实现 (Go 语言示例)

为了更好地理解反向代理的工作原理，我们可以用 Go 语言编写一个简单的反向代理服务器。

6.1 项目结构

/reverse-proxy-demo
├── static/
│   ├── index.html     # 前端页面
│   ├── styles.css     # 样式文件
│   └── script.js      # 前端逻辑
├── backend/
│   ├── server1/       # 后端服务器1
│   │   └── main.go    # 8081端口服务
│   └── server2/       # 后端服务器2
│       └── main.go    # 8082端口服务
├── proxy/
│   └── main.go        # 反向代理服务器
├── go.mod
└── go.sum

static/: 存放前端静态资源，包括 HTML、CSS 和 JavaScript 文件。
backend/: 包含两个模拟的后端服务器，分别监听 8081 和 8082 端口。
proxy/: 包含反向代理服务器的代码。
go.mod、go.sum: go 的依赖

6.2 前端 (`index.html`, `styles.css`, `script.js`)

index.html:
- 定义了用户界面，包括一个文本输入框 (messageInput)、一个服务器选择下拉框 (serverSelect) 和一个发送按钮。
- 使用 <link> 标签引入 styles.css 进行样式美化。
- 使用 <script> 标签引入 script.js 处理用户交互和与后端的通信。

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <title>反向代理演示</title>
    <link rel="stylesheet" href="/static/styles.css">
</head>
<body>
    <div class="container">
        <h1>反向代理负载均衡演示</h1>

        <div class="input-section">
            <textarea id="messageInput" placeholder="请输入要发送的消息..."></textarea>
            <div class="controls">
                <select id="serverSelect">
                    <option value="8081">服务器 8081</option>
                    <option value="8082">服务器 8082</option>
                </select>
                <button onclick="sendMessage()">发送</button>
            </div>
        </div>

        <div class="history-section">
            <h2>通信历史</h2>
            <div id="messageHistory"></div>
        </div>
    </div>
    <script src="/static/script.js"></script>
</body>
</html>

script.js:
- sendMessage() 函数：
  - 获取用户输入的消息和选择的服务器。
  - 使用 fetch API 向反向代理服务器发送 POST 请求。
  - 请求的 URL 为 /api/server${server}，其中 ${server} 是用户选择的服务器端口（8081 或 8082）。
  - 请求体使用 JSON 格式，包含 message 字段。
  - 处理响应，将消息和响应添加到通信历史中。
  - 错误处理：如果请求失败，弹出错误提示。
- addMessageToHistory(): * 创建消息历史,包含时间，发送与接收的信息 * 更新到页面


async function sendMessage() {
    const message = document.getElementById('messageInput').value;
    const server = document.getElementById('serverSelect').value;
    
    if (!message.trim()) {
        alert('请输入消息内容！');
        return;
    }

    try {
        const response = await fetch(`/api/server${server}`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({ message: message }),
        });

        const data = await response.json();
        addMessageToHistory(message, data.response, server);
        document.getElementById('messageInput').value = '';
    } catch (error) {
        console.error('Error:', error);
        alert('发送消息失败！');
    }
}

function addMessageToHistory(message, response, server) {
    const historyDiv = document.getElementById('messageHistory');
    const timestamp = new Date().toLocaleString();
    
    const messageItem = document.createElement('div');
    messageItem.className = 'message-item';
    messageItem.innerHTML = `
        <div class="timestamp">${timestamp} - 服务器 ${server}</div>
        <div>发送: ${message}</div>
        <div>响应: ${response}</div>
    `;
    
    historyDiv.insertBefore(messageItem, historyDiv.firstChild);
}

6.3 后端服务器 (`backend/server1/main.go`, `backend/server2/main.go`)

这两个后端服务器的代码基本相同，只是监听的端口不同。以 server1/main.go 为例：

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
)

type Request struct {
	Message string `json:"message"`
}

type Response struct {
	Response string `json:"response"`
}

func handler(w http.ResponseWriter, r *http.Request) {
	var req Request
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	response := Response{Response: "收到消息：" + req.Message}
	w.Header().Set("Content-Type", "application/json")
	if err := json.NewEncoder(w).Encode(&response); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func main() {
	http.HandleFunc("/api/server8081", handler)
	fmt.Println("服务器 8081 启动，监听端口 8081")
	log.Fatal(http.ListenAndServe(":8081", nil))
}

定义了 Request 和 Response 结构体，分别对应请求和响应的数据格式。
handler 函数：
- 解析请求体中的 JSON 数据到 Request 结构体。
- 构造一个 Response 结构体，包含对消息的确认。
- 将 Response 结构体编码为 JSON 格式，并设置响应头 Content-Type 为 application/json。
- 将 JSON 响应发送给客户端。
main 函数：
- 使用 http.HandleFunc 将 /api/server8081 路径映射到 handler 函数。
- 启动 HTTP 服务器，监听 8081 端口。

server2/main.go 与 server1/main.go 类似，只是监听端口为 8082，处理路径为 /api/server8082。

6.4 反向代理服务器 (`proxy/main.go`)

package main

import (
	"fmt"
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
)

func main() {
	// 定义后端服务器的地址
	servers := map[string]string{
		"8081": "http://localhost:8081",
		"8082": "http://localhost:8082",
	}

	// 创建反向代理处理器
	director := func(req *http.Request) {
		target, ok := servers[req.URL.Path[len("/api/server"):]]
		if !ok {
			// 如果找不到对应的后端服务器，返回错误
			// 在实际应用中，这里可以实现更复杂的路由逻辑
			req.URL.Scheme = "http" // 设置一个默认值，避免 panic
			req.URL.Host = "localhost"
			return
		}
		targetURL, _ := url.Parse(target)

		req.URL.Scheme = targetURL.Scheme
		req.URL.Host = targetURL.Host
		req.URL.Path = "/api/server" + req.URL.Path[len("/api/server"):] // 保持路径一致
		req.Host = targetURL.Host
	}

	proxy := &httputil.ReverseProxy{Director: director}

	// 注册静态文件服务
	fs := http.FileServer(http.Dir("static"))
	http.Handle("/static/", http.StripPrefix("/static/", fs))

	// 注册反向代理服务
	http.HandleFunc("/api/", func(w http.ResponseWriter, r *http.Request) {
		proxy.ServeHTTP(w, r)
	})

	fmt.Println("反向代理服务器启动，监听端口 3000")
	log.Fatal(http.ListenAndServe(":3000", nil))
}

servers 变量：定义了后端服务器的映射关系，键是服务器标识（8081、8082），值是服务器的完整 URL。
director 函数：
- 这是 httputil.ReverseProxy 的核心，用于修改请求。
- 根据请求路径 (/api/server8081 或 /api/server8082) 从 servers 中获取目标服务器的 URL。
- 修改请求的 URL.Scheme、URL.Host 和 URL.Path，使其指向目标服务器。
- 设置 req.Host 为目标服务器的地址。
proxy 变量：创建 httputil.ReverseProxy 实例，并设置 Director 为自定义的 director 函数。
静态文件服务：
- 使用 http.FileServer 创建一个文件服务器，服务于 static 目录。
- 使用 http.StripPrefix 移除请求路径中的 /static/ 前缀。
反向代理服务：
- 使用 http.HandleFunc 将 /api/ 开头的路径映射到 proxy.ServeHTTP，由反向代理处理。
启动服务器：
- 启动 HTTP 服务器，监听 3000 端口。

6.5 运行与测试

启动后端服务器：

go run backend/server1/main.go
go run backend/server2/main.go

启动反向代理服务器：
```
go run proxy/main.go
```
访问应用： 在浏览器中打开 http://localhost:3000，即可看到前端页面。输入消息，选择服务器，点击发送按钮，即可测试反向代理的功能。

效果图

6.6 代码分析与展望

路由逻辑：在 director 函数中，我们使用了简单的字符串匹配来确定目标服务器。在实际应用中，可以根据请求的更多信息（例如头部、参数、HTTP 方法等）来实现更复杂的路由逻辑。
负载均衡算法：这个示例中，前端通过选择服务器来决定请求发送到哪个后端。在实际应用中，反向代理服务器可以实现各种负载均衡算法（如轮询、最少连接、IP 哈希等），自动将请求分配给后端服务器。
健康检查：可以添加健康检查机制，定期检查后端服务器的状态，如果服务器无响应，则将其从可用服务器列表中移除。
SSL/TLS：可以配置反向代理服务器来处理 SSL/TLS 加密和解密，实现 SSL 终端的功能。
错误处理：在 director 函数中，我们简单地处理了找不到对应后端服务器的情况。在实际应用中，应该添加更完善的错误处理机制，例如返回自定义的错误页面或重试请求。
日志记录：可以添加日志记录功能，记录请求和响应的详细信息，方便调试和监控。

7.结语

（这里留着填写对于代码的修改记录）

深入浅出：反向代理从原理应用到代码示例

深入浅出：反向代理从原理应用到代码示例

0.说明

1. 代理与正向代理

2. 反向代理：概念与基本原理

3. 反向代理的核心功能与优势

3.1 负载均衡 (Load Balancing)

3.2 高可用性 (High Availability)

3.3 安全性 (Security)

3.4 SSL 终端 (SSL Termination)

3.5 缓存 (Caching)

3.6 API 网关与微服务架构

4. 报文处理

5. 反向代理的实现与应用

小结

6. 反向代理的代码实现 (Go 语言示例)

6.1 项目结构

6.2 前端 (index.html, styles.css, script.js)

6.3 后端服务器 (backend/server1/main.go, backend/server2/main.go)

6.4 反向代理服务器 (proxy/main.go)

6.5 运行与测试

6.6 代码分析与展望

7.结语

6.2 前端 (`index.html`, `styles.css`, `script.js`)

6.3 后端服务器 (`backend/server1/main.go`, `backend/server2/main.go`)

6.4 反向代理服务器 (`proxy/main.go`)