Повторне використання http-з’єднань у Golang

Question 1

Зараз я намагаюся знайти спосіб повторного використання з’єднань під час створення повідомлень HTTP у Golang.

Я створив транспорт і клієнта так:

// 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 ("За замовчуванням Транспорт кешує з'єднання для подальшого повторного використання.")

Отже, якщо ви створюєте новий транспорт для кожного запиту, він створюватиме нові зв’язки кожного разу. У цьому випадку рішення полягає у спільному використанні одного транспортного екземпляра між клієнтами.

Question 5

IIRC, клієнт за замовчуванням виконує повторне використання з'єднань. Ви закриваєте відповідь ?

Користувачі, які телефонують, повинні закрити відповідно тіло, коли читають з нього. Якщо 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.Oncely ви можете бути впевнені, що тільки один екземпляр буде використаний для всіх ваших запитів.

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. Transportне використовує TCP-з'єднання повторно, але слід обмежити 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

Є два можливі шляхи:

Використовуйте бібліотеку, яка внутрішньо повторно використовує та управляє дескрипторами файлів, пов’язаними з кожним запитом. Клієнт HTTP робить те саме внутрішньо, але тоді ви будете мати контроль над тим, скільки одночасних з'єднань відкрити, і як керувати своїми ресурсами. Якщо вам цікаво, подивіться на реалізацію netpoll, яка внутрішньо використовує epoll / kqueue для управління ними.
Найпростішим було б замість об’єднання мережевих з'єднань створити робочий пул для своїх програм. Це було б легким та кращим рішенням, яке не заважало б вашій поточній кодовій базі і вимагало б незначних змін.

Припустимо, вам потрібно зробити n запит POST після отримання запиту.

Ви можете використовувати канали для реалізації цього.

Або просто ви могли б використовувати сторонні бібліотеки.
Подобається: https://github.com/ivpusic/grpool