Go实现多域名透明反向代理方法

本文详细介绍了如何利用Go语言的`net/http/httputil.ReverseProxy`实现一个透明的反向代理，将同一物理机上不同域名的请求（如`mydomainA.com`和`mydomainB.com`）路由至运行在不同本地端口的后端服务。通过配置主代理服务器监听标准HTTP端口，并根据请求的`Host`头进行动态转发，确保用户和搜索引擎机器人感知不到重定向，从而提供无缝的服务访问体验。

引言

在现代Web服务架构中，常常需要在同一台物理服务器上托管多个域名，并将这些域名的请求分发到运行在不同端口的本地服务上。传统的做法可能包括使用HTTP重定向（例如http.RedirectHandler），但这会导致客户端浏览器地址栏URL发生变化，用户和搜索引擎会感知到重定向，这通常不是我们期望的“透明”转发。为了实现对用户完全透明的请求路由，我们需要一个反向代理。Go语言的标准库net/http/httputil包提供了ReverseProxy类型，正是解决此类问题的强大工具。

理解反向代理与httputil.ReverseProxy

反向代理服务器位于客户端和后端服务器之间。当客户端发起请求时，请求首先到达反向代理，反向代理根据预设的规则（如域名、URL路径等）将请求转发给相应的后端服务器，并将后端服务器的响应原封不动地返回给客户端。整个过程中，客户端并不知道与之交互的实际上是反向代理，而非直接的后端服务。

httputil.ReverseProxy是Go标准库提供的一个结构体，它实现了http.Handler接口，能够接收HTTP请求并将其转发到另一个HTTP服务器。其核心在于一个Director函数，该函数在请求被转发到后端之前，有机会修改原始请求（例如，修改请求的URL、Host头、添加/删除其他HTTP头等）。

实现多域名请求的透明路由

要实现将不同域名的请求路由到不同的本地服务，我们可以遵循以下步骤：

1. 定义后端服务映射： 创建一个映射表，将每个域名与对应的后端服务地址关联起来。
2. 创建自定义HTTP处理器： 实现一个http.Handler，该处理器将检查传入请求的Host头。
3. 动态选择或创建ReverseProxy实例： 根据Host头的值，从预定义的映射中找到对应的后端服务地址，并使用httputil.NewSingleHostReverseProxy为该后端创建一个ReverseProxy实例（或者从一个预创建的池中获取）。
4. 转发请求： 调用选定ReverseProxy实例的ServeHTTP方法，将请求转发给后端服务。

下面是一个完整的Go语言示例代码，演示了如何构建这样一个多域名反向代理：

package main

import (
    "fmt"
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
    "os"
    "os/signal"
    "syscall"
    "time"
)

// 定义后端服务器映射：域名 -> 目标URL
var backendMap = map[string]*url.URL{
    "mydomainA.com": {Scheme: "http", Host: "localhost:1234"},
    "mydomainB.com": {Scheme: "http", Host: "localhost:4567"},
}

// CustomMuxer 结构体作为主代理服务器的处理器
type CustomMuxer struct {
    // 存储预创建的 ReverseProxy 实例，以提高效率
    proxies map[string]*httputil.ReverseProxy
}

// NewCustomMuxer 初始化 CustomMuxer，为每个后端服务创建 ReverseProxy 实例
func NewCustomMuxer() *CustomMuxer {
    proxies := make(map[string]*httputil.ReverseProxy)
    for domain, targetURL := range backendMap {
        // NewSingleHostReverseProxy 创建一个简单的反向代理，
        // 默认的 Director 会将请求的 Scheme、Host 和 URL 路径修改为目标 URL 的值。
        // 并且会将 req.Host 头设置为 targetURL.Host。
        // 它还会处理 X-Forwarded-For 头。
        proxy := httputil.NewSingleHostReverseProxy(targetURL)

        // 可选：如果需要更精细地控制请求头，可以覆盖或包装默认的 Director。
        // 例如，添加自定义头或修改 X-Forwarded-For 逻辑。
        // defaultDirector := proxy.Director // 保存默认 Director
        // proxy.Director = func(req *http.Request) {
        //     defaultDirector(req) // 先执行默认 Director 的逻辑
        //     // req.Header.Set("X-Custom-Header", "Value") // 添加自定义头
        // }

        proxies[domain] = proxy
    }
    return &CustomMuxer{proxies: proxies}
}

// ServeHTTP 实现 http.Handler 接口，根据请求的 Host 头转发请求
func (m *CustomMuxer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    host := req.Host // 获取请求的 Host 头 (e.g., "mydomainA.com")

    if proxy, ok := m.proxies[host]; ok {
        log.Printf("Routing request for %s%s to backend: %s\n", host, req.URL.Path, backendMap[host].Host)
        proxy.ServeHTTP(w, req) // 将请求转发给对应的反向代理
    } else {
        log.Printf("No backend found for host: %s%s\n", host, req.URL.Path)
        http.Error(w, "Not Found", http.StatusNotFound) // 未找到匹配的后端服务
    }
}

func main() {
    // 启动两个模拟的后端服务器，以便测试
    go startBackendServer("1234", "Server A")
    go startBackendServer("4567", "Server B")

    // 确保后端服务器有时间启动
    time.Sleep(1 * time.Second)

    // 启动主代理服务器
    muxer := NewCustomMuxer()
    proxyPort := ":8080" // 生产环境通常使用 :80 或 :443
    log.Printf("Starting reverse proxy on %s\n", proxyPort)

    server := &http.Server{
        Addr:    proxyPort,
        Handler: muxer,
    }

    // 优雅关机处理
    go func() {
        sigChan := make(chan os.Signal, 1)
        signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
        <-sigChan
        log.Println("Shutting down proxy server...")
        if err := server.Shutdown(nil); err != nil {
            log.Fatalf("Proxy server shutdown error: %v", err)
        }
    }()

    if err := server.ListenAndServe(); err != http.ErrServerClosed {
        log.Fatalf("Proxy server failed to start: %v", err)
    }
    log.Println("Proxy server stopped.")
}

// 模拟后端服务器，用于测试反向代理功能
func startBackendServer(port, name string) {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello from %s on port %s!\nRequest path: %s\nHost header received: %s\nX-Forwarded-For: %v\n",
            name, port, r.URL.Path, r.Host, r.Header.Get("X-Forwarded-For"))
        log.Printf("%s (port %s) received request for %s, Host: %s\n", name, port, r.URL.Path, r.Host)
    })
    log.Printf("%s listening on :%s\n", name, port)
    if err := http.ListenAndServe(":"+port, nil); err != nil {
        log.Fatalf("Backend %s server failed to start on port %s: %v", name, port, err)
    }
}

如何测试：

1. 运行上述Go程序。 它将启动主代理服务器在:8080，以及两个模拟后端服务器在:1234和:4567。
2. 修改hosts文件： 为了模拟域名解析，你需要修改操作系统的hosts文件（Windows: C:\Windows\System32\drivers\etc\hosts，Linux/macOS: /etc/hosts）。添加以下两行：

   127.0.0.1 mydomainA.com
   127.0.0.1 mydomainB.com

   这将使你的系统在访问mydomainA.com和mydomainB.com时，解析到本地IP地址。

3. **通过浏览器或`curl