Client HTTP en Go : effectuer des requêtes correctement

Introduction : Pourquoi le client HTTP en Go mérite votre attention

Les applications web modernes fonctionnent rarement de manière isolée. Presque tous les services interagissent avec des API externes, des microservices ou des ressources tierces via HTTP. Le langage Go (Golang) fournit une bibliothèque intégrée puissante net/http qui permet de créer des clients HTTP efficaces et performants sans dépendances tierces.

Dans cet article, nous allons décomposer comment utiliser correctement le client HTTP en Go : des simples requêtes GET à la gestion des erreurs et des délais d'attente. Vous apprendrez à éviter les erreurs courantes et à écrire un code fiable.

Les bases du travail avec le client HTTP en Go

La bibliothèque net/http en Go est conçue pour la performance. Contrairement à de nombreux autres langages où chaque requête crée une nouvelle connexion, Go utilise par défaut un pool de connexions. Cela signifie que les connexions TCP sont réutilisées, ce qui accélère considérablement les opérations.

Requête GET simple

Commençons par l'exemple le plus simple — envoyer une requête GET en utilisant la fonction http.Get() :

package main

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

func main() {    // Simple GET request    resp, err := http.Get("https://api.github.com")    if err != nil {        fmt.Printf("Error executing request: %v", err)        os.Exit(1)    }    defer resp.Body.Close()

    // Read response body    body, err := io.ReadAll(resp.Body)    if err != nil {        fmt.Printf("Error reading response: %v", err)        os.Exit(1)    }

    fmt.Printf("Status: %s", resp.Status)    fmt.Printf("Response body: %s", string(body))}

Important : fermez toujours le corps de la réponse (resp.Body.Close()). Utilisez defer pour une fermeture garantie, même en cas d'erreur.

Requête GET avec paramètres et en-têtes

Pour des requêtes plus complexes, il est préférable d'utiliser la syntaxe complète en créant un objet http.Request :

package main

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

func main() {    // Create a new client    client := &http.Client{        Timeout: 10 * time.Second,    }

    // Create a request    req, err := http.NewRequest("GET", "https://api.example.com/users", nil)    if err != nil {        fmt.Printf("Error creating request: %v", err)        return    }

    // Add headers    req.Header.Set("Authorization", "Bearer your-token-here")    req.Header.Set("Accept", "application/json")    req.Header.Set("User-Agent", "Go-http-client/1.0")

    // Add query parameters    q := req.URL.Query()    q.Add("limit", "10")    q.Add("offset", "0")    req.URL.RawQuery = q.Encode()

    // Execute the request    resp, err := client.Do(req)    if err != nil {        fmt.Printf("Error executing request: %v", err)        return    }    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)    fmt.Printf("Response: %s", string(body))}

Travail avec les requêtes POST et JSON

Les requêtes POST avec un corps JSON sont une tâche standard lors du travail avec les API REST. Go fournit des outils pratiques pour la sérialisation des données.

Envoi de JSON via POST

package main

import (    "bytes"    "encoding/json"    "fmt"    "net/http"    "time")

type User struct {    Name  string `json:"name"`    Email string `json:"email"`    Age   int    `json:"age"`}

func main() {    user := User{        Name:  "Ivan Petrov",        Email: "ivan@example.com",        Age:   30,    }

    // Serialize the struct to JSON    jsonData, err := json.Marshal(user)    if err != nil {        fmt.Printf("JSON serialization error: %v", err)        return    }

    client := &http.Client{Timeout: 5 * time.Second}