http.Compétences en optimisation des transports et partage de pratiques en langage Go

Partage de conseils et pratiques d'optimisation de http.Transport en langage Go

Introduction :
En langage Go, utiliser http.Transport pour faire des requêtes réseau est une opération très courante. Cependant, dans le cadre de requêtes simultanées à grande échelle, une utilisation déraisonnable de http.Transport peut facilement entraîner des goulots d'étranglement dans les performances des requêtes réseau. Cet article explorera certaines techniques et pratiques d'optimisation pour aider les développeurs à mieux améliorer les performances des requêtes réseau.

1. Utiliser le pool de connexions
Par défaut, http.Transport créera une connexion simultanée pour chaque requête HTTP. L'avantage est que cela permet d'utiliser pleinement les capacités de traitement simultanées du serveur, mais cela entraînera également certains problèmes. Premièrement, la création et la fermeture fréquentes de connexions peuvent entraîner une surcharge inutile en termes de performances. Deuxièmement, le serveur peut avoir une limite sur le nombre de connexions, et un trop grand nombre de requêtes simultanées peut provoquer un déni de service sur le serveur. Par conséquent, l’utilisation du regroupement de connexions peut efficacement éviter ces problèmes.

Exemple de code :

package main

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

var client *http.Client

func init() {
    transport := &http.Transport{
        MaxIdleConns:        100,               // 最大空闲连接数
        IdleConnTimeout:     90 * time.Second,  // 空闲连接的超时时间
        TLSHandshakeTimeout: 10 * time.Second,  // TLS握手的超时时间
        ExpectContinueTimeout: 1 * time.Second, // 100-continue状态响应的超时时间
    }
    client = &http.Client{
        Transport: transport,
        Timeout:   10 * time.Second, // 完整请求的超时时间
    }
}

func main() {
    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求错误：", err)
        return
    }
    defer resp.Body.Close()

    // 处理响应
    // ...
}

2. Activer Keep-Alive

Keep-Alive est un mécanisme pour les connexions HTTP persistantes, qui permet au client et au serveur d'envoyer plusieurs requêtes et réponses HTTP sur la même connexion TCP. L'activation de Keep-Alive peut réduire le coût d'établissement de la connexion et améliorer les performances des requêtes réseau.

Dans http.Transport, Keep-Alive est activé par défaut. Mais si le serveur ne prend pas en charge Keep-Alive, les connexions seront quand même créées et fermées fréquemment. Par conséquent, nous pouvons contrôler le nombre maximum de connexions inactives par hôte en définissant la propriété MaxIdleConnsPerHost de http.Transport, réduisant ainsi la fréquence de création et de fermeture de connexion.

Exemple de code :

package main

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

var client *http.Client

func init() {
    transport := &http.Transport{
        MaxIdleConns:        100,               // 最大空闲连接数
        MaxIdleConnsPerHost: 10,                // 每个host的最大空闲连接数
        IdleConnTimeout:     90 * time.Second,  // 空闲连接的超时时间
        TLSHandshakeTimeout: 10 * time.Second,  // TLS握手的超时时间
        ExpectContinueTimeout: 1 * time.Second, // 100-continue状态响应的超时时间
    }
    client = &http.Client{
        Transport: transport,
        Timeout:   10 * time.Second, // 完整请求的超时时间
    }
}

func main() {
    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求错误：", err)
        return
    }
    defer resp.Body.Close()

    // 处理响应
    // ...
}

3. Activer la réutilisation des connexions

Dans certains scénarios où les requêtes doivent être envoyées fréquemment, l'activation de la réutilisation des connexions peut optimiser davantage les performances. La réutilisation de la connexion fait référence au maintien de la connexion TCP ouverte après l'envoi d'une requête afin que la connexion puisse continuer à être utilisée la prochaine fois que la requête est effectuée.

Exemple de code :

package main

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

var client *http.Client

func init() {
    transport := &http.Transport{
        MaxIdleConns:        100,                // 最大空闲连接数
        MaxIdleConnsPerHost: 10,                 // 每个host的最大空闲连接数
        IdleConnTimeout:     90 * time.Second,   // 空闲连接的超时时间
        TLSHandshakeTimeout: 10 * time.Second,   // TLS握手的超时时间
        ExpectContinueTimeout: 1 * time.Second,  // 100-continue状态响应的超时时间
        DisableKeepAlives:   false,              // 启用连接复用
    }
    client = &http.Client{
        Transport: transport,
        Timeout:   10 * time.Second,  // 完整请求的超时时间
    }
}

func main() {
    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求错误：", err)
        return
    }
    defer resp.Body.Close()

    // 处理响应
    // ...
}

Conclusion :
En utilisant le pooling de connexions, en activant Keep-Alive et la réutilisation des connexions, nous pouvons améliorer efficacement les performances des requêtes réseau en utilisant http.Transport en langage Go. Bien entendu, des optimisations et des ajustements supplémentaires peuvent être nécessaires pour différents scénarios et besoins commerciaux. J'espère que cet article pourra être utile aux développeurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!