使用 Go 构建网络代理和反向代理：实战指南

发布: 4天前 (2026年1月12日 GMT+8 09:45)

12 min read

Source: Dev.to

请提供您想要翻译的完整文本（除代码块和 URL 之外），我会按照要求将其译成简体中文并保持原有的 Markdown 格式。

为什么选择代理？

Go 是网络编程的强大工具：

功能	为什么它适合代理
`net/http` package	简化 HTTP 请求/响应处理
Goroutines	轻松实现并发请求的扩展
Single binary	零麻烦部署，随处运行

您将学到

正向代理和反向代理的区别。
如何使用 Go 构建两者，提供清晰、可用于生产的代码。
优化技巧以及我十年 Go 经验中的实战教训。

让我们开始吧！

网络代理 vs. 反向代理：基础

在编写代码之前，让我们先弄清楚代理的作用。它们是网络通信中的中间人，但角色不同。

正向代理 – 客户端的代理人

正向代理位于客户端（例如你的浏览器）和互联网之间，代表客户端获取资源。可以把它想象成一个私人助理，在不透露你是请求者的情况下帮你取咖啡。

工作原理：Client → Proxy → Server → Proxy → Client
使用场景：匿名（VPN）、内容过滤、缓存
Go 的优势：http.Client 简化转发；Goroutine 处理并发客户端。

反向代理 – 服务器的守门员

反向代理位于后端服务器前面，路由客户端请求并保护后端。它就像餐厅的接待员，把你的点单分配给合适的厨师。

工作原理：Client → Reverse Proxy → Backend → Reverse Proxy → Client
使用场景：负载均衡（Nginx）、安全、API 网关
Go 的优势：httputil.ReverseProxy 让路由变得轻而易举；Goroutine 可扩展流量。

正向 vs. 反向 – 快速对比

功能	正向代理	反向代理
角色	为客户端提供服务	为后端提供服务
控制	客户端配置	服务器管理
目的	隐藏客户端身份	隐藏后端细节
Go 工具	`http.Client`	`httputil.ReverseProxy`

第2节：在 Go 中构建正向代理

让我们动手实现一个简单的 HTTP 正向代理。该代码会将客户端请求转发到任意目标服务器并返回响应——非常适合匿名或缓存场景！

Go 中的简易正向代理

package main

import (
	"io"
	"log"
	"net/http"
)

func handleProxy(w http.ResponseWriter, r *http.Request) {
	// Create a client that will forward the request
	client := &http.Client{}

	// Build a new request based on the incoming one
	req, err := http.NewRequest(r.Method, r.URL.String(), r.Body)
	if err != nil {
		http.Error(w, "Bad Request", http.StatusBadRequest)
		return
	}

	// Copy request headers
	for k, v := range r.Header {
		req.Header[k] = v
	}

	// Forward the request
	resp, err := client.Do(req)
	if err != nil {
		http.Error(w, "Server Error", http.StatusInternalServerError)
		return
	}
	defer resp.Body.Close()

	// Copy response headers and status code
	for k, v := range resp.Header {
		w.Header()[k] = v
	}
	w.WriteHeader(resp.StatusCode)

	// Stream the response body to the client
	io.Copy(w, resp.Body)
}

func main() {
	http.HandleFunc("/", handleProxy)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

运行它

将文件保存为 proxy.go。
运行 go run proxy.go。

使用以下命令测试：

curl -x http://localhost:8080 http://example.com

发生了什么

http.Client 将客户端的请求发送到目标服务器。
复制请求头和请求体，以保留原始请求的完整信息。
io.Copy 高效地流式传输响应。
defer resp.Body.Close() 防止文件描述符泄漏。

专业提示 – 始终关闭 resp.Body。在生产环境中忘记关闭会导致文件描述符耗尽。

优化技巧

在实际的内容过滤代理中，我通过以下调优提升了性能：

连接池

client := &http.Client{
	Transport: &http.Transport{
		MaxIdleConns:        100,
		MaxIdleConnsPerHost: 10,
		IdleConnTimeout:    90 * time.Second,
		TLSHandshakeTimeout: 10 * time.Second,
	},
	Timeout: 30 * time.Second,
}

结果：通过复用连接，延迟从约 200 ms 降至约 50 ms。

陷阱修复 – 设置 MaxIdleConnsPerHost 以限制每个主机的连接数，避免过多的 TCP 握手。

Source:

第 3 节：在 Go 中构建反向代理

现在，让我们构建一个带有轮询负载均衡的反向代理，以在多个后端之间分配请求。非常适合微服务或高流量应用！

简单的轮询反向代理

package main

import (
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
	"sync/atomic"
)

// ReverseProxy holds the backend URLs and the current index.
type ReverseProxy struct {
	backends []*url.URL
	current  uint64
}

// NewReverseProxy parses the backend URLs and returns a proxy instance.
func NewReverseProxy(backendURLs []string) *ReverseProxy {
	urls := make([]*url.URL, len(backendURLs))
	for i, u := range backendURLs {
		parsed, err := url.Parse(u)
		if err != nil {
			log.Fatalf("Invalid backend URL %q: %v", u, err)
		}
		urls[i] = parsed
	}
	return &ReverseProxy{backends: urls}
}

// getNextBackend returns the next backend URL using atomic round‑robin.
func (p *ReverseProxy) getNextBackend() *url.URL {
	idx := atomic.AddUint64(&p.current, 1)
	return p.backends[idx%uint64(len(p.backends))]
}

// ServeHTTP satisfies http.Handler and forwards the request.
func (p *ReverseProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	target := p.getNextBackend()

	// Create a reverse proxy for the selected backend.
	proxy := httputil.NewSingleHostReverseProxy(target)

	// Optionally modify the request before sending it upstream.
	originalDirector := proxy.Director
	proxy.Director = func(req *http.Request) {
		originalDirector(req)
		// Preserve the original Host header if you need it.
		req.Host = target.Host
	}

	proxy.ServeHTTP(w, r)
}

func main() {
	// Example backends – replace with your own services.
	backends := []string{
		"http://localhost:8081",
		"http://localhost:8082",
		"http://localhost:8083",
	}

	proxy := NewReverseProxy(backends)

	log.Println("Reverse proxy listening on :8080")
	if err := http.ListenAndServe(":8080", proxy); err != nil {
		log.Fatalf("Server failed: %v", err)
	}
}

工作原理

轮询选择 – getNextBackend 通过原子操作挑选下一个后端 URL。
httputil.NewSingleHostReverseProxy – 负责请求重写、响应复制以及连接复用。
自定义 Director – 允许你在向上游发送请求前进行微调（例如保留原始的 Host 头部）。

测试方法

# 启动三个简单的后端服务器（例如使用 Python 的 http.server）
python3 -m http.server 8081 &
python3 -m http.server 8082 &
python3 -m http.server 8083 &

# 运行反向代理
go run reverse_proxy.go

# 发送请求
curl http://localhost:8080
curl http://localhost:8080
curl http://localhost:8080

你会看到请求依次由这三个后端提供服务。

专业提示 – 在生产环境中，建议加入健康检查、优雅关闭以及 TLS 终止等功能。

总结

代理是掌握 Go 网络栈的绝佳练习场。通过前向代理示例，你已经拥有了实现匿名或内容过滤的基础，而带有轮询负载均衡的反向代理则展示了如何构建轻量级的 API 网关或边缘路由器。

欢迎随意 fork 这些代码片段，尝试 TLS，添加缓存层，或集成指标（Prometheus、OpenTelemetry）。祝编码愉快，愿你的 Go 协程永不阻塞！ 🚀

第 3 部分：Go 语言简易反向代理

package main

import (
	"log"
	"net/http"
	"net/http/httputil"
	"net/url"
	"sync/atomic"
)

type ReverseProxy struct {
	backends []*url.URL
	counter  uint64
}

func NewReverseProxy(backends []string) *ReverseProxy {
	urls := make([]*url.URL, len(backends))
	for i, b := range backends {
		u, err := url.Parse(b)
		if err != nil {
			log.Fatalf("invalid backend URL %s: %v", b, err)
		}
		urls[i] = u
	}
	return &ReverseProxy{backends: urls}
}

func (p *ReverseProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// Round‑robin selection
	index := atomic.AddUint64(&p.counter, 1) % uint64(len(p.backends))
	proxy := httputil.NewSingleHostReverseProxy(p.backends[index])
	proxy.ServeHTTP(w, r)
}

func main() {
	backends := []string{"http://localhost:8081", "http://localhost:8082"}
	proxy := NewReverseProxy(backends)
	log.Fatal(http.ListenAndServe(":8080", proxy))
}

运行方法

将文件保存为 reverse_proxy.go。
在 8081 和 8082 端口上启动模拟后端（例如，简单的 Go HTTP 服务器）。
执行 go run reverse_proxy.go。
使用 curl http://localhost:8080 进行测试。

发生了什么

httputil.ReverseProxy 负责请求转发。
atomic.AddUint64 确保线程安全的轮询（Round‑Robin）选择，使请求在后端之间交替。

专业提示 – 启用连接复用：

proxy.Transport = &http.Transport{
    MaxIdleConns:        100,
    MaxIdleConnsPerHost: 10,
}

实际应用洞察

健康检查

func (p *ReverseProxy) healthCheck() {
    for {
        for _, backend := range p.backends {
            resp, err := http.Get(backend.String() + "/health")
            // 根据 err / resp.StatusCode 更新后端状态
            if resp != nil {
                resp.Body.Close()
            }
        }
        time.Sleep(10 * time.Second)
    }
}

常见坑的修复

设置 ResponseHeaderTimeout 以避免慢后端导致的延迟。

高级特性与最佳实践

让我们通过并发、安全性和监控等高级特性提升，并结合最佳实践，使你的代理达到生产就绪水平。

高并发

Go 的 goroutine 在这里大显身手。每个请求在自己的轻量级线程中运行，能够以极低的内存处理成千上万的连接。对于动态后端，使用线程安全的管理器：

type BackendManager struct {
    backends []*url.URL
    mu       sync.RWMutex
}

func (m *BackendManager) UpdateBackends(newBackends []string) {
    m.mu.Lock()
    defer m.mu.Unlock()
    urls := make([]*url.URL, len(newBackends))
    for i, u := range newBackends {
        urls[i], _ = url.Parse(u)
    }
    m.backends = urls
}

洞察 – 将其与 Consul 配合使用，可在 Kubernetes 中实现零停机的后端更新。

安全

TLS – 使用 http.ListenAndServeTLS 并通过 golang.org/x/crypto/acme/autocert 使用 Let’s Encrypt。
速率限制 – 使用 golang.org/x/time/rate 缓解 DDoS：

limiter := rate.NewLimiter(10, 50) // 10 reqs/sec, 50 burst
if !limiter.Allow() {
    http.Error(w, "Rate Limit Exceeded", http.StatusTooManyRequests)
    return
}

监控

性能分析 – 在 :6060 上启用 net/http/pprof，获取 CPU/内存信息。
指标 – 使用 prometheus/client_golang 生成 Prometheus/Grafana 仪表盘。

问题修复 – 缺少指标导致调试噩梦。部署 Prometheus 来跟踪 http_requests_total。

最佳实践

超时 – 为 http.Client 和 http.Transport 设置超时，以防止卡死。
日志 – 使用 go.uber.org/zap 进行结构化、高性能日志记录。
部署 – 使用 Docker 容器化：

FROM golang:1.21
WORKDIR /app
COPY . .
RUN go build -o proxy
CMD ["./proxy"]

洞察 – Nginx + Go 进行 SSL 终止，使性能提升约 20%。

实际案例与行动号召

API 网关

将请求路由到带有认证的微服务：

mux := http.NewServeMux()
mux.Handle("/users/", httputil.NewSingleHostReverseProxy(userService))
mux.Handle("/orders/", httputil.NewSingleHostReverseProxy(orderService))

提示 – 使用 http.StripPrefix 以避免路由冲突。

负载均衡器

使用一致性哈希（github.com/stathat/consistent）来提升缓存命中率并实现动态健康检查。

缓存代理

使用 sync.Map 和 TTL 缓存静态内容：

type CacheEntry struct {
    Data      []byte
    ExpiresAt time.Time
}

p.cache.Store(key, CacheEntry{
    Data:      data,
    ExpiresAt: time.Now().Add(5 * time.Minute),
})

洞察 – 这将缓存命中率从 60 % 提升至 85 %。

关键要点

Go 的 net/http 和 httputil 让代理开发变得直截了当。
Goroutine 和连接池轻松处理高流量。
健康检查和 TLS 等优化确保可靠性。

行动号召

构建您自己的代理！尝试以下任意一种：

使用 Let’s Encrypt 的 TLS 启用正向代理。
带有 Prometheus 监控的反向代理。

在评论中分享您的项目——我很想看到您的作品！有问题或遇到卡顿？留下评论，让我们一起调试。 🚀

使用 Go 构建网络代理和反向代理：实战指南

为什么选择代理？

您将学到

网络代理 vs. 反向代理：基础

正向代理 – 客户端的代理人

反向代理 – 服务器的守门员

正向 vs. 反向 – 快速对比

第2节：在 Go 中构建正向代理

Go 中的简易正向代理

运行它

发生了什么

优化技巧

连接池

第 3 节：在 Go 中构建反向代理

简单的轮询反向代理

工作原理

测试方法

总结

第 3 部分：Go 语言简易反向代理

运行方法

发生了什么

实际应用洞察

健康检查

常见坑的修复

高级特性与最佳实践

高并发

安全

监控

最佳实践

实际案例与行动号召

API 网关

负载均衡器

缓存代理

关键要点

行动号召

相关文章

我们如何衡量 HTTP 时延：DNS、TCP、TLS、TTFB 细分

精通 Go 中的 HTTP/2：构建更快 Web 服务器的实用指南

Go (Golang) 入门：面向开发者的实用指南

在 Go 中让并行 HTTP 请求更稳定：构建 Markdown Linter 的经验教训

为什么选择代理？

您将学到

网络代理 vs. 反向代理：基础

正向代理 – 客户端的代理人

反向代理 – 服务器的守门员

正向 vs. 反向 – 快速对比

第2节：在 Go 中构建正向代理

Go 中的简易正向代理

运行它

发生了什么

优化技巧

连接池

第 3 节：在 Go 中构建反向代理

简单的轮询反向代理

工作原理

测试方法

总结

第 3 部分：Go 语言简易反向代理

运行方法

发生了什么

实际应用洞察

健康检查

常见坑的修复

高级特性与最佳实践

高并发

安全

监控

最佳实践

实际案例与行动号召

API 网关

负载均衡器

缓存代理

关键要点

行动号召

相关文章

我们如何衡量 HTTP 时延：DNS、TCP、TLS、TTFB 细分

精通 Go 中的 HTTP/2：构建更快 Web 服务器的实用指南

Go (Golang) 入门：面向开发者的实用指南

在 Go 中让并行 HTTP 请求更稳定：构建 Markdown Linter 的经验教训

第 3 节：在 Go 中构建反向代理

第 3 部分：Go 语言简易反向代理