Golangでのhttp接続の再利用

Question 1

私は現在、GolangでHTTP投稿を行うときに接続を再利用する方法を見つけるのに苦労しています。

私は次のようなトランスポートとクライアントを作成しました：

// Create a new transport and HTTP client
tr := &http.Transport{}
client := &http.Client{Transport: tr}

次に、このクライアントポインターを、次のように同じエンドポイントに複数の投稿を行うゴルーチンに渡します。

r, err := client.Post(url, "application/json", post)

netstatを見ると、これによりすべての投稿に新しい接続が発生し、多数の同時接続が開かれているように見えます。

この場合、接続を再利用する正しい方法は何ですか？

Question 2

あなたがいることを確認し、応答が完了するまで読んで、コールClose()。

例えば

res, _ := client.Do(req)
io.Copy(ioutil.Discard, res.Body)
res.Body.Close()

繰り返しますが...http.Client接続を確実に再利用するには、次のことを確認してください。

応答が完了するまで読み取ります（つまりioutil.ReadAll(resp.Body)）
コール Body.Close()

Question 3

誰かがまだそれを行う方法についての答えを見つけているなら、これは私がそれをしている方法です。

package main

import (
    "bytes"
    "io/ioutil"
    "log"
    "net/http"
    "time"
)

var httpClient *http.Client

const (
    MaxIdleConnections int = 20
    RequestTimeout     int = 5
)

func init() {
    httpClient = createHTTPClient()
}

// createHTTPClient for connection re-use
func createHTTPClient() *http.Client {
    client := &http.Client{
        Transport: &http.Transport{
            MaxIdleConnsPerHost: MaxIdleConnections,
        },
        Timeout: time.Duration(RequestTimeout) * time.Second,
    }

    return client
}

func main() {
    endPoint := "https://localhost:8080/doSomething"

    req, err := http.NewRequest("POST", endPoint, bytes.NewBuffer([]byte("Post this data")))
    if err != nil {
        log.Fatalf("Error Occured. %+v", err)
    }
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

    response, err := httpClient.Do(req)
    if err != nil && response == nil {
        log.Fatalf("Error sending request to API endpoint. %+v", err)
    }

    // Close the connection to reuse it
    defer response.Body.Close()

    // Let's check if the work actually is done
    // We have seen inconsistencies even when we get 200 OK response
    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        log.Fatalf("Couldn't parse response body. %+v", err)
    }

    log.Println("Response Body:", string(body))    
}

遊び場に行く：http：//play.golang.org/p/oliqHLmzSX

要約すると、HTTPクライアントを作成し、それをグローバル変数に割り当ててから、それを使用してリクエストを行うための別のメソッドを作成しています。注意してください

defer response.Body.Close()

これにより、接続が閉じられ、再利用できるようになります。

これが誰かを助けることを願っています。

Question 4

編集：これは、すべてのリクエストに対してトランスポートとクライアントを構築する人々のためのメモです。

Edit2：リンクをgodocに変更しました。

Transport再利用のための接続を保持する構造体です。https://godoc.org/net/http#Transportを参照してください（「デフォルトでは、トランスポートは将来の再利用のために接続をキャッシュします。」）

したがって、リクエストごとに新しいトランスポートを作成すると、毎回新しい接続が作成されます。この場合の解決策は、クライアント間で1つのトランスポートインスタンスを共有することです。

Question 5

IIRC、デフォルトのクライアントは接続を再利用します。応答を閉じていますか？

呼び出し元は、resp.Bodyからの読み取りが完了したら、resp.Bodyを閉じる必要があります。resp.Bodyが閉じられていない場合、クライアントの基盤となるRoundTripper（通常はTransport）は、後続の「キープアライブ」要求のためにサーバーへの永続的なTCP接続を再利用できない可能性があります。

Question 6

ボディについて

// It is the caller's responsibility to
// close Body. The default HTTP client's Transport may not
// reuse HTTP/1.x "keep-alive" TCP connections if the Body is
// not read to completion and closed.

したがって、TCP接続を再利用する場合は、読み取りが完了するたびにBodyを閉じる必要があります。関数ReadBody（io.ReadCloser）はこのように提案されています。

package main

import (
    "fmt"
    "io"
    "io/ioutil"
    "net/http"
    "time"
)

func main() {
    req, err := http.NewRequest(http.MethodGet, "https://github.com", nil)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    client := &http.Client{}
    i := 0
    for {
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println(err.Error())
            return
        }
        _, _ = readBody(resp.Body)
        fmt.Println("done ", i)
        time.Sleep(5 * time.Second)
    }
}

func readBody(readCloser io.ReadCloser) ([]byte, error) {
    defer readCloser.Close()
    body, err := ioutil.ReadAll(readCloser)
    if err != nil {
        return nil, err
    }
    return body, nil
}

Question 7

別のアプローチinit()は、シングルトンメソッドを使用してhttpクライアントを取得することです。sync.Onceを使用すると、すべてのリクエストで1つのインスタンスのみが使用されるようになります。

var (
    once              sync.Once
    netClient         *http.Client
)

func newNetClient() *http.Client {
    once.Do(func() {
        var netTransport = &http.Transport{
            Dial: (&net.Dialer{
                Timeout: 2 * time.Second,
            }).Dial,
            TLSHandshakeTimeout: 2 * time.Second,
        }
        netClient = &http.Client{
            Timeout:   time.Second * 2,
            Transport: netTransport,
        }
    })

    return netClient
}

func yourFunc(){
    URL := "local.dev"
    req, err := http.NewRequest("POST", URL, nil)
    response, err := newNetClient().Do(req)
    // ...
}

Question 8

ここで欠けているのは「ゴルティン」なことです。トランスポートには独自の接続プールがあり、デフォルトではそのプール内の各接続が再利用されます（本体が完全に読み取られて閉じられている場合）が、複数のゴルーチンがリクエストを送信している場合、新しい接続が作成されます（プールにはすべての接続がビジーであり、新しい接続が作成されます））。これを解決するには、ホストごとの接続の最大数を制限する必要があります：Transport.MaxConnsPerHost（https://golang.org/src/net/http/transport.go#L205）。

おそらく、セットアップIdleConnTimeoutおよび/またはResponseHeaderTimeout。

Question 9

https://golang.org/src/net/http/transport.go#L196

をMaxConnsPerHost明示的に設定する必要がありますhttp.Client。TransportTCP接続を再利用しますが、制限する必要がありますMaxConnsPerHost（デフォルトの0は制限がないことを意味します）。

func init() {
    // singleton http.Client
    httpClient = createHTTPClient()
}

// createHTTPClient for connection re-use
func createHTTPClient() *http.Client {
    client := &http.Client{
        Transport: &http.Transport{
            MaxConnsPerHost:     1,
            // other option field
        },
        Timeout: time.Duration(RequestTimeout) * time.Second,
    }

    return client
}

Question 10

2つの可能な方法があります：

各リクエストに関連付けられたファイル記述子を内部で再利用および管理するライブラリを使用します。Httpクライアントは内部で同じことを行いますが、開く同時接続の数とリソースの管理方法を制御できます。興味がある場合は、内部でepoll / kqueueを使用して管理するnetpollの実装をご覧ください。
簡単な方法は、ネットワーク接続をプールする代わりに、ゴルーチン用のワーカープールを作成することです。これは簡単でより良い解決策であり、現在のコードベースを妨げることはなく、小さな変更が必要になります。

リクエストを受け取った後、nPOSTリクエストを行う必要があると仮定しましょう。

これを実装するには、チャネルを使用できます。

または、単にサードパーティのライブラリを使用することもできます。
いいね：https： //github.com/ivpusic/grpool