我已经开始研究缓存，以便将经常从各种 S3 服务器中提取的 S3 对象放入我们的数据中心。其中一些是 GB 大小，许多服务器都在请求相同的对象。所以为了提高性能，需要这个缓存。

但是，与我见过的其他 S3 缓存不同，我不需要 s3 身份验证部分。它已经包含在我的客户请求的 header 中。

所以计划是解析请求，检查对象是否完全存在于本地，或者当前正在获取。完成后，返回结果。 对象被方便地散列。因此，如果它的内容发生变化，它就是一个新的散列和一个新的对象。

请求已包含使用 S3 进行身份验证所需的一切。但是我有点卡住的地方是我不熟悉 HTTP 的代理连接协议(protocol)。我修改了一些我发现不使用 Hijack 的示例开始代码，因此我可以解释正在发生的事情并决定我是否需要实际获取上游对象。但它不起作用。客户吐槽:

获取https://example.com : tls: 第一条记录看起来不像是 TLS 握手

嗯嗯。

这是监听 HTTP 的代理(它将在防火墙后面，所以为了简单起见，我故意让它不安全)。

package main

import (
    "crypto/tls"
    "io"
    "log"
    "net"
    "net/http"
    "time"
)

func handleTunneling(w http.ResponseWriter, r *http.Request) {
    dest_conn, err := net.DialTimeout("tcp", r.Host, 10*time.Second)
    if err != nil {
        http.Error(w, err.Error(), http.StatusServiceUnavailable)
        return
    }
    w.WriteHeader(http.StatusOK)
    hijacker, ok := w.(http.Hijacker)
    if !ok {
        http.Error(w, "Hijacking not supported", http.StatusInternalServerError)
        return
    }
    client_conn, _, err := hijacker.Hijack()
    if err != nil {
        http.Error(w, err.Error(), http.StatusServiceUnavailable)
    }
    go transfer(dest_conn, client_conn)
    go transfer(client_conn, dest_conn)
}

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

func handleHTTP(w http.ResponseWriter, req *http.Request) {
    resp, err := http.DefaultTransport.RoundTrip(req)
    if err != nil {
        http.Error(w, err.Error(), http.StatusServiceUnavailable)
        return
    }
    defer resp.Body.Close()

    log.Println(req.RemoteAddr, " ", resp.Status)

    copyHeader(w.Header(), resp.Header)
    w.WriteHeader(resp.StatusCode)
    io.Copy(w, resp.Body)
}

func copyHeader(dst, src http.Header) {
    for k, vv := range src {
        for _, v := range vv {
            dst.Add(k, v)
        }
    }
}

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 {
                handleHTTP(w, r)
            }
        }),
        // Disable HTTP/2.
        TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler)),
    }

    log.Fatal(server.ListenAndServe())
}

客户端看起来像这样:

package main

import (
    "net/http"
    "fmt"
    "io/ioutil"
    "os"
    "net/url"
)

func main() {  
    args := os.Args[1:]
    var whereTo string
    if len(args) > 0 {
        whereTo = args[0]
    } else {
        fmt.Println("Usage: htclient [url]")
        os.Exit(1)
    }

    proxyUrl, err := url.Parse("http://localhost:8080")
    client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}

    req, err := http.NewRequest("GET", whereTo, nil)

    response, err := client.Do(req)
    if err != nil {
        fmt.Printf("%s", err)
        os.Exit(1)
    } else {
        defer response.Body.Close()
        contents, err := ioutil.ReadAll(response.Body)
        if err != nil {
            fmt.Printf("%s", err)
            os.Exit(1)
        }
        fmt.Printf("%s\n", string(contents))
    }
}

建议？

最佳答案

您发送 200 OK 响应的时间过早；检查错误后发送。

https://www.rfc-editor.org/rfc/rfc7231#section-4.3.6 (强调我的):

CONNECT is intended only for use in requests to a proxy. An origin server that receives a CONNECT request for itself MAY respond with a 2xx (Successful) status code to indicate that a connection is established.

func handleTunneling(w http.ResponseWriter, r *http.Request) {
    dest_conn, err := net.DialTimeout("tcp", r.Host, 10*time.Second)
    if err != nil {
        http.Error(w, err.Error(), http.StatusServiceUnavailable)
        return
    }

    // too early: w.WriteHeader(http.StatusOK)

    hijacker, ok := w.(http.Hijacker)
    if !ok {
        http.Error(w, "Hijacking not supported", http.StatusInternalServerError)
        return
    }
    client_conn, _, err := hijacker.Hijack()
    if err != nil {
        http.Error(w, err.Error(), http.StatusServiceUnavailable)
        return // missing in your sample code
    }

    w.WriteHeader(http.StatusOK) // respond 2xx here
    go transfer(dest_conn, client_conn)
    go transfer(client_conn, dest_conn)
}

关于go - go 中的 http 到 https 代理，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49892499/