I am trying to build a web scraping utility that allows anyone to run a program and have their computer act as a forward proxy, mainly to get around IP blocking. The high level overview of this would work as follows:

我正在尝试建立一个网络抓取实用程序，允许任何人运行一个程序，并让他们的计算机充当转发代理，主要是为了绕过IP阻止。这方面的高级别概览的工作方式如下：

Requester --sends http request--> Centralized server --distributes request to random client--> 
Client --sends request to target server--> Target server --responds back down to requester--> 
Client --> Centralized server -> Requester

The tricky part of this is allowing the client to act as a forward proxy, without actually exposing any ports (as I want this to have no tricky networking setup, e.g. port forwarding). Additionally, I believe it makes sense for the Centralized server to look like a typical forward proxy to to the Requester, so it could work with the following code:

其中棘手的部分是允许客户端充当转发代理，而不实际暴露任何端口（因为我希望这没有棘手的网络设置，例如端口转发）。此外，我认为集中式服务器看起来像一个典型的转发代理到转发器是有意义的，所以它可以使用以下代码：

func main() {
    proxyURL, err := url.Parse("http://localhost:8080")
    if err != nil {
        panic(err)
    }
    httpClient := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
    }
    response, err := httpClient.Get("https://example.com/")
    if err != nil {
        panic(err)
    }
    log.Println("Response status:", response.Status)
}

My original design involved having each client open a websocket connection to the server, thus removing the need for them to have exposed ports. Then, raw HTTP requests would be sent to the client, who would relay the request/response to/from the target server. However, I've been having alot of trouble getting it working properly. Here is my attempt:

我最初的设计包括让每个客户端打开到服务器的WebSocket连接，从而消除了它们具有公开端口的需要。然后，原始的HTTP请求将被发送到客户端，客户端将向目标服务器转发请求/响应，或从目标服务器转发请求/响应。然而，我在让它正常工作方面遇到了很多麻烦。以下是我的尝试：

// I don't know what the implementation of this would be.
type WSClient interface {
    io.Reader
    io.Writer
    io.Closer
}

func main() {
    var wsConn WSClient
    proxy := func(w http.ResponseWriter, req *http.Request) {
        client, _, err := w.(http.Hijacker).Hijack()
        if err != nil {
            w.WriteHeader(502)
            fmt.Fprint(w, err)
            return
        }
        client.Write([]byte("HTTP/1.0 200 OK\r\n\r\n"))

        go func() {
            _, err = io.Copy(wsConn, client)
            if err != nil {
                fmt.Println(err)
                return
            }
            client.Close()
        }()
        go func() {
            _, err := io.Copy(client, wsConn)
            if err != nil {
                fmt.Println(err)
                return
            }
            wsConn.Close()
        }()
    }
    http.ListenAndServe(":8080", http.HandlerFunc(proxy))
}

I don't really know where to go from here, nor does this feel like the right way to accomplish my goal of a super easy-to-setup forward proxy. Would anyone be able to point me in the right direction, or give me some code samples to help me get closer to my desired functionality?

我真的不知道从哪里开始，这也不是实现我的目标--一个超级易于设置的转发代理--的正确方式。有没有人能为我指明正确的方向，或者给我一些代码样例来帮助我更接近我想要的功能？

Edit: Some people have mentioned that without opening ports, I cannot receive any requests to forward. I am hoping to send the requests via a web socket opened by the client, thus bypassing this restriction.

编辑：有人提到，如果不开放端口，我就无法收到任何转发请求。我希望通过客户端打开的Web套接字发送请求，从而绕过这一限制。

Unless the proxies request originate locally (and I mean internally vs. over any network connection, even from the loopback), you are going to have listeners, which by your definition, I think would be "exposed".

除非代理请求源自本地(我指的是内部与通过任何网络连接，甚至来自环回)，否则您将拥有监听程序，根据您的定义，我认为它将被“暴露”。

I think you mean "exposed" ports as in it listens for inbound connections, the classic approach is to have have the proxy server setup on as a bastion, with one network interface on the internet and one on the intranet.

我想你的意思是“暴露的”端口，因为它监听入站连接，经典的方法是将代理服务器设置为堡垒，一个网络接口在互联网上，一个在内部网上。

Your proxy listens on the intranet, and only makes outbound connections on the internet.

您的代理监听内部网，并且只在Internet上建立出站连接。

By definition, a web proxy (forward or reverse) has to listen for a request.

根据定义，Web代理(正向或反向)必须侦听请求。