Golang实现localhost内部API间通信的方法探讨

在启用nginx的情况下进行localhost内部API调用，需要确保内部请求正确路由到后端Go服务器。以下是解决方案和示例代码：

问题分析

当nginx作为反向代理时，内部API调用应该使用：

1. 内部网络地址（localhost:8282）而不是外部域名
2. HTTP协议而不是HTTPS（因为nginx已经处理了SSL终止）

解决方案

1. 修改内部API调用使用HTTP和正确端口

func Create_user(w http.ResponseWriter, r *http.Request) {
    encode_data := Get_encoded_form_values(w, r)
    decode_data := JSON_struct{}
    tmplsrv.Decoding(encode_data, &decode_data)
    params := url.Values{
        "email":    {r.FormValue("email")},
        "password": {r.FormValue("password")},
    }
    
    // 关键修改：使用HTTP协议和8282端口
    check_user_answer := Requester("http://localhost:8282/check_user/", w, r, encode_data, params)
    answer := Answer{}
    tmplsrv.Decoding(check_user_answer, &answer)
    
    if answer.Answr == "NotFound" {
        // 同样修改这里
        new_token_answer := Requester("http://localhost:8282/create_token/", w, r, encode_data, params)
        tmplsrv.Decoding(new_token_answer, &answer)
        decode_data.JWT_token = answer.Answr
        database.Inserting_user_in_db(tmplsrv.Encoding(decode_data))
        w.WriteHeader(http.StatusCreated)
        w.Write([]byte("created"))
    }
    
    if answer.Answr == "" {
        w.Write([]byte("Unable to create user"))
    } else {
        w.Write([]byte("User exists"))
    }
}

2. 创建通用的内部请求函数

func InternalRequester(endpoint string, w http.ResponseWriter, r *http.Request, encode_data []byte, params url.Values) []byte {
    // 构建内部API URL
    internalURL := fmt.Sprintf("http://localhost:8282%s", endpoint)
    
    // 创建新的HTTP请求
    req, err := http.NewRequest("POST", internalURL, strings.NewReader(params.Encode()))
    if err != nil {
        return []byte(`{"Answr":""}`)
    }
    
    // 复制原始请求的头部信息
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
    req.Header.Set("X-Forwarded-For", r.RemoteAddr)
    
    // 发送请求
    client := &http.Client{
        Timeout: time.Second * 10,
    }
    
    resp, err := client.Do(req)
    if err != nil {
        return []byte(`{"Answr":""}`)
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return []byte(`{"Answr":""}`)
    }
    
    return body
}

// 使用示例
func Create_user(w http.ResponseWriter, r *http.Request) {
    encode_data := Get_encoded_form_values(w, r)
    decode_data := JSON_struct{}
    tmplsrv.Decoding(encode_data, &decode_data)
    params := url.Values{
        "email":    {r.FormValue("email")},
        "password": {r.FormValue("password")},
    }
    
    // 使用内部请求函数
    check_user_answer := InternalRequester("/check_user/", w, r, encode_data, params)
    // ... 其余代码
}

3. 配置nginx传递原始主机头（可选）

修改nginx配置以确保正确的头部传递：

location / {
    proxy_pass http://localhost:8282/;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

4. 使用环境变量配置API端点

var (
    internalAPIHost = os.Getenv("INTERNAL_API_HOST")
    internalAPIPort = os.Getenv("INTERNAL_API_PORT")
)

func getInternalAPIURL(endpoint string) string {
    if internalAPIHost == "" {
        internalAPIHost = "localhost"
    }
    if internalAPIPort == "" {
        internalAPIPort = "8282"
    }
    return fmt.Sprintf("http://%s:%s%s", internalAPIHost, internalAPIPort, endpoint)
}

// 使用示例
func Create_user(w http.ResponseWriter, r *http.Request) {
    // ...
    check_user_url := getInternalAPIURL("/check_user/")
    check_user_answer := Requester(check_user_url, w, r, encode_data, params)
    // ...
}

关键点

1. 协议：内部调用使用HTTP（nginx已处理HTTPS）
2. 端口：直接使用Go服务器的8282端口
3. 地址：使用localhost或127.0.0.1
4. 头部传递：确保nginx正确传递请求头

这样修改后，内部API调用将通过HTTP直接访问Go服务器，绕过nginx的SSL和外部路由逻辑，确保内部通信正常。