如何本地调试有IP限制的三方接口

location /xxxx/ {
      access_by_lua '
        ngx.req.set_uri_args(params)   验证等
      ';
      proxy_pass http://原始网址;
      proxy_cache cache_one;
      proxy_cache_valid 200 304 302 90s;
      proxy_cache_bypass $arg_nocache;
   }
}Copy

package main

import (
    "encoding/base64"
    "io"
    "log"
    "net"
    "net/http"
    "strings"
)

// 用户认证信息
var (
    proxyUsername = "user"
    proxyPassword = "password"
)

func handleTunneling(w http.ResponseWriter, r *http.Request) {
    if !checkProxyAuth(r) {
        w.Header().Set("Proxy-Authenticate", `Basic realm="Proxy Authentication"`)
        http.Error(w, "Proxy Authentication Required", http.StatusProxyAuthRequired)
        return
    }

    destConn, err := net.Dial("tcp", r.Host)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    w.WriteHeader(http.StatusOK)
    hijacker, ok := w.(http.Hijacker)
    if !ok {
        http.Error(w, "Hijacking not supported", http.StatusInternalServerError)
        return
    }
    clientConn, _, err := hijacker.Hijack()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    go transfer(destConn, clientConn)
    go transfer(clientConn, destConn)
}

func handleHTTP(w http.ResponseWriter, req *http.Request) {
    if !checkProxyAuth(req) {
        w.Header().Set("Proxy-Authenticate", `Basic realm="Proxy Authentication"`)
        http.Error(w, "Proxy Authentication Required", http.StatusProxyAuthRequired)
        return
    }

    // 修改请求的URL
    transport := http.DefaultTransport
    outReq := new(http.Request)
    *outReq = *req // 复制请求

    if req.URL.Scheme != "http" && req.URL.Scheme != "https" {
        http.Error(w, "Unsupported scheme", http.StatusBadRequest)
        return
    }

    // 发送请求
    res, err := transport.RoundTrip(outReq)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadGateway)
        return
    }
    defer res.Body.Close()

    // 复制响应头
    for key, value := range res.Header {
        w.Header()[key] = value
    }
    w.WriteHeader(res.StatusCode)

    // 复制响应体
    io.Copy(w, res.Body)
}

func checkProxyAuth(r *http.Request) bool {
    // 检查代理授权头
    auth := r.Header.Get("Proxy-Authorization")
    if auth == "" {
        return false
    }

    // 解码认证信息
    creds, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(auth, "Basic "))
    if err != nil {
        return false
    }

    // 验证用户名和密码
    if string(creds) != proxyUsername+":"+proxyPassword {
        return false
    }

    return true
}

func transfer(destination io.WriteCloser, source io.ReadCloser) {
    defer destination.Close()
    defer source.Close()
    io.Copy(destination, source)
}

func main() {
    server := &http.Server{
        Addr: ":8080",
        Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            if r.Method == http.MethodConnect {
                handleTunneling(w, r)
            } else {
                // 处理HTTP请求
                handleHTTP(w, r)
            }
        }),
    }

    log.Fatal(server.ListenAndServe())
}Copy

$config = [
    'proxy' =>  'http://user:password@xx.xx.xx.xx:8080'
];
$client = new \GuzzleHttp\Client($config);
$res = $client->get("https://httpbin.org/get");
$res = $client->get("http://httpbin.org/get");Copy