Comment définir les en-têtes dans une requête HTTP GET en Go : guide complet

Comment définir les en-têtes dans une requête HTTP GET en Go ? Explication complète avec code

Avez-vous déjà essayé d'envoyer une requête HTTP GET à un serveur, et il renvoyait une erreur d'autorisation ? Ou peut-être que l'API ignorait votre requête, alors que vous saviez pertinemment qu'elle devait fonctionner ? Dans 90 % des cas, le problème réside dans les en-têtes HTTP. C'est comme un laissez-passer pour une fête : sans le bon document, vous ne serez tout simplement pas admis.

Dans cet article, nous allons voir comment gérer professionnellement les en-têtes dans les requêtes HTTP GET en Go (Golang). Vous apprendrez non seulement la syntaxe de base, mais aussi les pièges typiques dans lesquels même les développeurs expérimentés tombent. C'est parti !

Pourquoi les en-têtes sont-ils importants ?

Imaginez qu'une requête HTTP est une enveloppe contenant une lettre. L'enveloppe elle-même (le corps de la requête) peut être vide, mais les informations sur celle-ci (les en-têtes) décident de tout :

\n
• Content-Type — le format des données (JSON, XML, Form)
\n
• Authorization — la clé d'accès à l'API (Bearer token, Basic Auth)
\n
• User-Agent — l'identification du client (pour ne pas être bloqué comme un bot)
\n
• Accept — le format de réponse attendu
\n

Sans les bons en-têtes, le serveur ne comprendra tout simplement pas ce que vous voulez de lui.

Méthode 1 : Le bon vieux http.Get (et pourquoi il ne convient pas)

De nombreux débutants en Go commencent avec http.Get(). C'est pratique pour les tests, mais cette méthode a un énorme inconvénient : on ne peut pas définir d'en-têtes.

package main\n\nimport (\n    "fmt"\n    "io/ioutil"\n    "net/http"\n)\n\nfunc main() {\n    // Impossible d'ajouter des en-têtes ainsi !\n    resp, err := http.Get("https://api.example.com/data")\n    if err != nil {\n        panic(err)\n    }\n    defer resp.Body.Close()\n\n    body, _ := ioutil.ReadAll(resp.Body)\n    fmt.Println(string(body))\n}\n

Ce code envoie simplement une requête « nue ». Si l'API nécessite un token d'autorisation, vous obtiendrez un 401 Unauthorized. Pour des projets réels, cette approche ne convient pas.

Méthode 2 : Créer sa propre requête (la bonne manière)

En Go, pour un réglage fin des requêtes, on utilise le constructeur http.NewRequest(). Il retourne un objet *http.Request avec lequel on peut faire tout ce qu'on veut, y compris définir des en-têtes.

Voici la structure de base :

package main\n\nimport (\n    "fmt"\n    "io/ioutil"\n    "net/http"\n)\n\nfunc main() {\n    // 1. Créer l'URL\n    url := "https://api.github.com/users/golang"\n\n    // 2. Créer une nouvelle requête GET\n    req, err := http.NewRequest("GET", url, nil)\n    if err != nil {\n        panic(err)\n    }\n\n    // 3. Définir les en-têtes\n    req.Header.Set("User-Agent", "MyGoApp/1.0")\n    req.Header.Set("Accept", "application/json")\n\n    // 4. Envoyer la requête via le client HTTP\n    client := &http.Client{}\n    resp, err := client.Do(req)\n    if err != nil {\n        panic(err)\n    }\n    defer resp.Body.Close()\n\n    body, _ := ioutil.ReadAll(resp.Body)\n    fmt.Println(string(body))\n}\n

Notez que nous utilisons req.Header.Set(), et non req.Header.Add(). La différence est importante :

\n
• Set — remplace la valeur existante (si cet en-tête existe déjà)
\n
• Add — ajoute une autre valeur à celle existante (crée un doublon)
\n

Pour la plupart des cas, utilisez Set — c'est plus sûr.

Méthode 3 : Travailler avec l'autorisation (Bearer Token)

Le scénario le plus courant est la transmission d'un token JWT. Voici comment faire correctement :

package main\n\nimport (\n    "fmt"\n    "net/http"\n)\n\nfunc main() {\n    token := "your_jwt_token_here"\n    url := "https://api.example.com/protected"\n\n    req, _ := http.NewRequest("GET", url, nil)\n\n    // Définir l'en-tête Authorization\n    req.Heade