使用 Nginx + Golang 实现重定向到 STUN 公网地址

小声de吐槽()#

在上篇文章使用 Lucky 的 STUN 内网穿透，实现公网 IPv4 访问中，我们实现了借助 Lucky 的 STUN 内网穿透，实现了在 NAT1 环境下，通过公网 IPv4 访问本地服务。

但是，我们的 公网 IPv4 地址和端口是动态的，变更频率不固定 ，这就导致了我们每次访问 STUN 公网地址时，都需要手动更新地址和端口。

这显然不符合慵懒猫猫的作风！~

为了实现固定域名访问公网地址，我们可以借助公网 Nginx 服务器以及 Golang，实现重定向到 STUN 公网地址。

访问流程#

访问固定域名 example.com
Nginx 服务器收到请求，将请求转发至 Golang 服务
Golang 服务收到请求后，根据 target_data.json 文件，302 重定向至最新的 STUN 公网地址和端口
用户浏览器收到重定向响应，自动访问 STUN 公网地址和端口

首先，我们先来配置 Nginx#

狐务器在哪里都可以，只要有公网 IP 即可。

安装 Nginx 的那些咱就不说了，自己搜索一下吧。这里直接给出反向代理的配置

127.0.0.1:8080 是 Golang 服务的监听地址，可以自定义的喵~

1
# 健康检查
2
location /health {
3
    proxy_pass http://127.0.0.1:8080;
4
    proxy_set_header Host $host;
5
    access_log off;
6
}
7

8
# Webhook 更新端点 (建议使用更复杂的路径)
9
location /internal/webhook {
10
    proxy_pass http://127.0.0.1:8080/webhook;
11
    proxy_set_header Host $host;
12
    proxy_set_header X-Real-IP $remote_addr;
13
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
14
    proxy_set_header X-Forwarded-Proto $scheme;
15
}
16

17
# 主重定向逻辑
18
location / {
19
    # 使用 proxy_pass 由 Golang 处理重定向
20
    proxy_pass http://127.0.0.1:8080;
21
    proxy_set_header Host $host;
22
    proxy_set_header X-Real-IP $remote_addr;
23
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
24
    proxy_set_header X-Forwarded-Proto $scheme;
25
}

然后，我们来配置 Golang 服务#

Golang 服务的代码如下：

1
package main
2

3
import (
4
  "encoding/json"
5
  "fmt"
6
  "log"
7
  "net/http"
8
  "os"
9
  "sync"
10
  "time"
11
)
12

13
// Config 配置结构体
14
type Config struct {
15
  Port       string `json:"port"`
16
  TargetFile string `json:"target_file"`
17
  AuthToken  string `json:"auth_token"`
18
}
19

20
// Target 目标地址结构体
21
type Target struct {
22
  IP         string    `json:"ip"`
23
  Port       string    `json:"port"`
24
  RuleName   string    `json:"rule_name"`
25
  UpdateTime time.Time `json:"update_time"`
26
}
27

28
var (
29
  config        Config
30
  currentTarget Target
31
  mutex         sync.RWMutex
32
)
33

34
// 加载配置
35
func loadConfig() error {
36
  config = Config{
37
    Port:       "8080",
38
    TargetFile: "target_data.json",
39
    AuthToken:  os.Getenv("WEBHOOK_TOKEN"), // 从环境变量获取token
40
  }
41

42
  // 可以从配置文件加载
43
  if file, err := os.ReadFile("config.json"); err == nil {
44
    json.Unmarshal(file, &config)
45
  }
46

47
  return nil
48
}
49

50
// 处理 Webhook 更新
51
func handleWebhook(w http.ResponseWriter, r *http.Request) {
52
  // 认证检查
53
  if config.AuthToken != "" {
54
    token := r.Header.Get("Authorization")
55
    if token != "Bearer "+config.AuthToken && token != config.AuthToken {
56
      http.Error(w, "Unauthorized", http.StatusUnauthorized)
57
      return
58
    }
59
  }
60

61
  if r.Method != http.MethodPost {
62
    http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
63
    return
64
  }
65

66
  var newTarget Target
67
  if err := json.NewDecoder(r.Body).Decode(&newTarget); err != nil {
68
    http.Error(w, "Invalid JSON", http.StatusBadRequest)
69
    return
70
  }
71

72
  if newTarget.IP == "" || newTarget.Port == "" {
73
    http.Error(w, "Missing IP or port", http.StatusBadRequest)
74
    return
75
  }
76

77
  newTarget.UpdateTime = time.Now()
78

79
  // 更新目标地址
80
  mutex.Lock()
81
  currentTarget = newTarget
82
  mutex.Unlock()
83

84
  // 保存到文件
85
  if err := saveTargetToFile(newTarget); err != nil {
86
    log.Printf("Failed to save target: %v", err)
87
    http.Error(w, "Internal server error", http.StatusInternalServerError)
88
    return
89
  }
90

91
  log.Printf("Target updated: %s:%s (Rule: %s)", newTarget.IP, newTarget.Port, newTarget.RuleName)
92

93
  w.Header().Set("Content-Type", "application/json")
94
  json.NewEncoder(w).Encode(map[string]string{
95
    "status":  "success",
96
    "message": fmt.Sprintf("Updated to %s:%s", newTarget.IP, newTarget.Port),
97
  })
98
}
99

100
// 获取当前目标地址
101
func handleGetTarget(w http.ResponseWriter, r *http.Request) {
102
  mutex.RLock()
103
  target := currentTarget
104
  mutex.RUnlock()
105

106
  w.Header().Set("Content-Type", "application/json")
107
  json.NewEncoder(w).Encode(target)
108
}
109

110
// 重定向端点 - 返回 302 重定向
111
func handleRedirect(w http.ResponseWriter, r *http.Request) {
112
  mutex.RLock()
113
  target := currentTarget
114
  mutex.RUnlock()
115

116
  if target.IP == "" || target.Port == "" {
117
    http.Error(w, "Target not configured", http.StatusServiceUnavailable)
118
    return
119
  }
120

121
  // 构建重定向 URL
122
  redirectURL := fmt.Sprintf("http://%s:%s%s", target.IP, target.Port, r.URL.Path)
123
  if r.URL.RawQuery != "" {
124
    redirectURL += "?" + r.URL.RawQuery
125
  }
126

127
  log.Printf("Redirecting to: %s", redirectURL)
128
  http.Redirect(w, r, redirectURL, http.StatusFound)
129
}
130

131
// 保存目标到文件
132
func saveTargetToFile(target Target) error {
133
  data, err := json.MarshalIndent(target, "", "  ")
134
  if err != nil {
135
    return err
136
  }
137
  return os.WriteFile(config.TargetFile, data, 0644)
138
}
139

140
// 从文件加载目标
141
func loadTargetFromFile() error {
142
  data, err := os.ReadFile(config.TargetFile)
143
  if err != nil {
144
    if os.IsNotExist(err) {
145
      return nil // 文件不存在是正常的
146
    }
147
    return err
148
  }
149

150
  var target Target
151
  if err := json.Unmarshal(data, &target); err != nil {
152
    return err
153
  }
154

155
  mutex.Lock()
156
  currentTarget = target
157
  mutex.Unlock()
158

159
  log.Printf("Loaded target from file: %s:%s", target.IP, target.Port)
160
  return nil
161
}
162

163
// 健康检查
164
func handleHealth(w http.ResponseWriter, r *http.Request) {
165
  w.Header().Set("Content-Type", "application/json")
166
  json.NewEncoder(w).Encode(map[string]string{
167
    "status":    "healthy",
168
    "timestamp": time.Now().Format(time.RFC3339),
169
  })
170
}
171

172
func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
173
  return func(w http.ResponseWriter, r *http.Request) {
174
    start := time.Now()
175
    next.ServeHTTP(w, r)
176
    log.Printf("%s %s %s %v", r.Method, r.URL.Path, r.RemoteAddr, time.Since(start))
177
  }
178
}
179

180
func main() {
181
  // 加载配置
182
  if err := loadConfig(); err != nil {
183
    log.Fatalf("Failed to load config: %v", err)
184
  }
185

186
  // 加载保存的目标数据
187
  if err := loadTargetFromFile(); err != nil {
188
    log.Printf("Warning: Failed to load target data: %v", err)
189
  }
190

191
  // 设置路由
192
  http.HandleFunc("/webhook", loggingMiddleware(handleWebhook))
193
  http.HandleFunc("/target", loggingMiddleware(handleGetTarget))
194
  http.HandleFunc("/health", loggingMiddleware(handleHealth))
195
  http.HandleFunc("/", loggingMiddleware(handleRedirect))
196

197
  log.Printf("Webhook server starting on port %s", config.Port)
198
  log.Printf("Target file: %s", config.TargetFile)
199

200
  if err := http.ListenAndServe(":"+config.Port, nil); err != nil {
201
    log.Fatalf("Server failed: %v", err)
202
  }
203
}

将 Golang 服务部署到服务器#

将编译好的二进制文件上传到服务器上，然后创建配置文件 config.json 内容如下：

1
{
2
  "port": "8080",
3
  "target_file": "target_data.json",
4
  "auth_token": "your-secret-token-here"
5
}

自行修改 port 和 auth_token 捏~

port 需要和 Nginx 配置中的 proxy_pass 端口一致。

然后就可以启动服务啦~

你可以使用 screen 或 tmux 等工具在后台运行它。

1
screen -S WebhookServer
2
./WebhookServer

然后，你可以使用 Ctrl+A+D 来 detach 这个 screen 会话。

或者，你也可以使用 systemd 来管理这个服务。

创建一个名为 webhook-server.service 的文件，放在 /etc/systemd/system/ 目录下，内容如下：

1
[Unit]
2
Description=Webhook Server
3
After=network.target
4

5
[Service]
6
Type=simple
7
WorkingDirectory=/path/to
8
ExecStart=/path/to/WebhookServer
9
Restart=always
10
RestartSec=5
11

12
[Install]
13
WantedBy=multi-user.target

将 /path/to 替换为你实际的二进制文件路径。

然后，启用并启动这个服务：

1
systemctl daemon-reload
2
systemctl enable webhook-server --now

你可以使用 systemctl status webhook-server 来检查服务状态。

配置 Lucky STUN Webhook#

配置项	说明
接口地址	`http://<指向Nginx的域名或IP>/webhook`
请求方法	`POST`
请求头	`Authorization: Bearer <auth_token>`
请求体	JSON 格式，参考示例
接口调用成功包含的字符串	填写 `success`

示例请求体#

1
{"ip":"#{ip}", "port":"#{port}", "rule_name":"#{ruleName}"}

填写完成后点击 Webhook手动触发测试 来验证配置是否正确。

正确无误后，点击 修改 来保存设置。

🎉 至此，全部就配置完成啦~#

现在你可以访问你的域名，看看是否能正常跳转了~