Client HTTP en Go : techniques avancées pour la gestion des requêtes

Client HTTP en Go : effectuer des requêtes correctement (niveau avancé)

Le package intégré net/http en Go offre des fonctionnalités puissantes, mais souvent sous-estimées, pour créer des clients HTTP fiables. Au niveau débutant, les développeurs utilisent http.Get ou http.Post, ce qui est pratique pour des prototypes rapides, mais totalement inadapté pour la production. Dans cet article, nous allons explorer les techniques avancées de configuration d'un client HTTP en Go : réglage fin des timeouts, gestion du pool de connexions, création de chaînes de middleware, implémentation de tentatives et gestion correcte des erreurs. Vous apprendrez à écrire un code client qui supporte des charges élevées et résiste aux pannes réseau.

1. Configuration des timeouts et du pool de connexions

L'erreur de base est d'utiliser http.DefaultClient. Il n'a pas de timeouts et peut rester bloqué indéfiniment. Pour la production, créez toujours votre propre instance de http.Client avec un réglage fin de http.Transport.

package main

import (    "net/http"    "time")

func NewClient() *http.Client {    transport := &http.Transport{        MaxIdleConns:        100,               // Maximum de connexions inactives dans tout le pool        MaxConnsPerHost:     10,                // Maximum de connexions vers un même hôte        MaxIdleConnsPerHost: 5,                 // Maximum de connexions inactives vers un même hôte        IdleConnTimeout:     90 * time.Second,  // Durée de vie d'une connexion inactive        DisableCompression:  false,             // Activation de la compression (gzip)    }

    client := &http.Client{        Transport: transport,        Timeout:   30 * time.Second, // Timeout global pour toute la requête    }    return client}

Analysons les paramètres clés :

• Timeout — limite de temps totale pour l'exécution de la requête (y compris la lecture du corps de la réponse). Définissez-le en fonction de la vitesse attendue de l'API (généralement 10 à 30 secondes).
• MaxIdleConns — nombre de connexions keep-alive stockées dans le pool. Pour les systèmes à forte charge, augmentez-le à 200-500.
• MaxConnsPerHost — limite le nombre de connexions simultanées vers un même hôte. Empêche la surcharge du serveur.

Il est également recommandé de définir DialContext avec un timeout personnalisé pour l'établissement de la connexion :

transport.DialContext = (&net.Dialer{    Timeout:   5 * time.Second,  // Timeout pour la poignée de main TCP    KeepAlive: 30 * time.Second, // Keep-alive pour maintenir la connexion}).DialContext

2. Création de chaînes de middleware pour le client HTTP

Go n'a pas de middleware intégré pour le client, mais nous pouvons facilement implémenter le modèle "décorateur" en enveloppant http.RoundTripper. Cela permet d'ajouter la journalisation, les métriques, l'authentification et d'autres fonctions transversales.

type LoggingRoundTripper struct {    Proxied http.RoundTripper}

func (l *LoggingRoundTripper) RoundTrip(r *http.Request) (*http.Response, error) {    start := time.Now()    resp, err := l.Proxied.RoundTrip(r)    duration := time.Since(start)

    log.Printf("[%s] %s %s - %d (%v)",        r.Method, r.URL.String(),        r.Host, resp.StatusCode, duration,    )    return resp, err}

// Utilisation :transport := &LoggingRoundTripper{    Proxied: http.DefaultTransport,}client := &http.Client{Transport: transport}

Vous pouvez créer une chaîne de middleware, par exemple pour ajouter des en-têtes d'authentification :

type AuthRoundTripper struct {    Proxied http.RoundTripper    Token   string}

func (a *AuthRoundTripper) RoundTrip(r *http.Request) (*http.Response, error) {    r.Header.Set("Authorization", "Bearer "+a.Token)    return a.Proxied.RoundTrip(r)}

// Chaîne : Auth → Logging → Transportclient := &http.Client{    Transport: &LoggingRoundTripper{