Aller au contenu
Encyclopédie informatique Édition 2026

Le langage Go

Partie 4 sur 4

Niveau de lecture :

8La bibliothèque standard et les outils

8.1Un serveur Web en quelques lignes

Go est livré avec une bibliothèque standard très complète, en particulier pour le réseau : serveur et client Web, formats JSON et XML, chiffrement, compression, accès aux bases de données. Un serveur Web tient en quelques lignes :

package main

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

func main() {
    http.HandleFunc("/heure", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, time.Now().Format(time.RFC3339))
    })
    srv := &http.Server{
        Addr:              ":8080",
        ReadHeaderTimeout: 5 * time.Second,   // voir le coin cyber
    }
    log.Fatal(srv.ListenAndServe())
}

8.2Les outils

Les outils font partie de la distribution : go test pour les tests et les mesures de performance, go vet pour repérer les constructions suspectes, go doc pour la documentation, pprof pour analyser la consommation de processeur et de mémoire, et govulncheck, qui signale les failles connues dans les bibliothèques utilisées, en ne retenant que celles que le programme appelle réellement.

8.3Les tests

Un test Go est une fonction dont le nom commence par Test, placée dans un fichier dont le nom se termine par _test.go. L’usage est d’écrire des tests en table : une liste de cas, chacun avec ses données et le résultat attendu, parcourue par une boucle. Ajouter un cas revient à ajouter une ligne :

func TestDiviser(t *testing.T) {
    cas := []struct {
        a, b, attendu float64
        erreur        bool
    }{
        {10, 4, 2.5, false},
        {1, 0, 0, true},
    }
    for _, c := range cas {
        q, err := Diviser(c.a, c.b)
        if (err != nil) != c.erreur || q != c.attendu {
            t.Errorf("Diviser(%v, %v) = %v, %v", c.a, c.b, q, err)
        }
    }
}

Depuis 2022, Go intègre aussi le test à données aléatoires (en anglais fuzzing) : la commande go test -fuzz génère automatiquement des milliers de données d’entrée inattendues, en les faisant évoluer pour explorer de nouveaux chemins du programme, et conserve celles qui provoquent un plantage. C’est une technique efficace pour trouver des failles dans le code qui analyse des données venues de l’extérieur, comme des fichiers ou des requêtes.

9Un exemple complet : surveiller des sites

Le programme suivant vérifie en parallèle que plusieurs sites Web répondent, avec un délai maximal de cinq secondes pour l’ensemble. Il réunit les notions vues plus haut : goroutines, canal, contexte d’annulation et traitement des erreurs.

package main

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

type Resultat struct {
    URL    string
    Statut string
}

func verifier(ctx context.Context, url string) Resultat {
    req, err := http.NewRequestWithContext(ctx, http.MethodHead, url, nil)
    if err != nil {
        return Resultat{url, "adresse invalide"}
    }
    rep, err := http.DefaultClient.Do(req)
    if err != nil {
        return Resultat{url, "injoignable : " + err.Error()}
    }
    defer rep.Body.Close()
    return Resultat{url, rep.Status}
}

func main() {
    sites := []string{
        "https://www.example.org",
        "https://intranet.example.org",
        "https://boutique.example.org",
    }
    ctx, annuler := context.WithTimeout(context.Background(), 5*time.Second)
    defer annuler()

    resultats := make(chan Resultat)
    for _, s := range sites {
        go func() { resultats <- verifier(ctx, s) }()
    }
    for range sites {
        r := <-resultats
        fmt.Printf("%-32s %s\n", r.URL, r.Statut)
    }
}

Chaque site est interrogé dans sa propre goroutine, si bien que la durée totale est celle du site le plus lent, et non la somme des durées. La requête utilise la méthode HEAD, qui demande seulement l’en-tête de la réponse, sans télécharger la page (voir HTTP). Le contexte limite l’attente : au bout de cinq secondes, toutes les requêtes encore en cours sont annulées et renvoient une erreur. Les résultats s’affichent dans l’ordre où ils arrivent. Pour surveiller des centaines de sites, on limiterait le nombre de goroutines simultanées, par exemple avec un canal servant de jeton, afin de ne pas saturer le réseau.

Pour s’exercer

Exercice 6 : le serveur trop patient

Un développeur lance son service avec http.ListenAndServe(":8080", mux). Un collègue lui conseille plutôt la forme de la section 8, avec ReadHeaderTimeout. Pourquoi ?

Voir la réponse

http.ListenAndServe crée un serveur sans aucun délai d’attente : il patientera indéfiniment pendant qu’un client envoie sa requête. Un attaquant peut alors ouvrir des milliers de connexions et envoyer ses en-têtes au compte-gouttes, quelques octets toutes les dix secondes, pour occuper toutes les ressources du serveur : c’est le principe de l’attaque dite « Slowloris », une forme de déni de service (voir le déni de service). En fixant des délais, ReadHeaderTimeout, ReadTimeout, WriteTimeout, IdleTimeout, le serveur coupe les connexions trop lentes. Placer le service derrière un relais inverse configuré ajoute une protection supplémentaire.

Exercice 7 : la goroutine oubliée

On attend un résultat au plus deux secondes :

resultat := make(chan string)
go func() { resultat <- calculLong() }()   // dure 3 secondes
select {
case r := <-resultat:
    fmt.Println(r)
case <-time.After(2 * time.Second):
    fmt.Println("trop tard")
}

Qu’affiche le programme ? Que devient la goroutine qui exécute calculLong ? Comment corriger ?

Voir la réponse

Le programme affiche « trop tard » au bout de deux secondes. Mais la goroutine, quand elle termine son calcul, essaie d’envoyer le résultat dans un canal que plus personne ne lit : elle reste bloquée pour toujours, avec la mémoire qu’elle occupe. Dans un serveur qui fait cela à chaque requête, ces fuites de goroutines s’accumulent jusqu’à épuiser la mémoire : un attaquant qui sait provoquer des calculs lents peut s’en servir pour un déni de service. Correction simple : créer un canal avec une place de réserve, make(chan string, 1), pour que l’envoi réussisse même sans lecteur ; correction plus complète : transmettre un contexte à calculLong pour qu’il s’arrête lui-même quand le délai expire. Go 1.26 propose à titre expérimental un outil qui détecte ces goroutines bloquées.

10Le langage du cloud

Go est devenu la langue commune de l’infrastructure : la plupart des outils qui servent à construire, déployer et surveiller les applications dans le cloud sont écrits en Go (figure 3). Les raisons tiennent à ses qualités : exécutables uniques faciles à distribuer, bonne gestion de milliers de connexions simultanées, performances suffisantes, code lisible par des contributeurs venus de partout (voir le cloud).

écrits en Go Conteneurs Docker Kubernetes containerd Infrastructure Terraform Vault Consul Supervision Prometheus Grafana Web et données Caddy Traefik Hugo etcd Une grande partie des outils du cloud moderne est écrite en Go.
Figure 3. Quelques outils majeurs de l’infrastructure, tous écrits en Go.

Au-delà de l’infrastructure, Go est utilisé pour les services en ligne de nombreuses entreprises, comme Uber, Twitch ou Cloudflare, pour les outils en ligne de commande, et pour de nombreux outils de sécurité : scanners de vulnérabilités, outils de collecte de journaux, agents de supervision. Il est en revanche peu présent dans les applications graphiques, le calcul scientifique ou l’intelligence artificielle, où dominent d’autres langages.

11Forces et limites

Forces

  • Simple à apprendre et à lire ; code homogène d’un projet à l’autre.
  • Compilation très rapide ; exécutable unique ; compilation croisée intégrée.
  • Programmation concurrente simple et efficace.
  • Bibliothèque standard riche et outils intégrés ; promesse de compatibilité tenue.

Limites

  • Traitement des erreurs répétitif et verbeux.
  • Langage volontairement peu expressif ; généricité tardive et limitée.
  • Le pointeur nul existe toujours : l’utiliser provoque un arrêt brutal.
  • Le ramasse-miettes, même rapide, rend Go moins adapté que Rust ou le C aux noyaux et aux systèmes temps réel.

Go et Rust sont souvent comparés. Ils visent des besoins différents : Go privilégie la productivité des équipes et la simplicité, Rust la maîtrise totale des performances et des garanties plus fortes, au prix d’un apprentissage plus long (voir Rust).

Pour une personne qui débute ou se reconvertit, Go est un bon deuxième langage, après Python : sa syntaxe tient en peu de pages, le compilateur signale clairement les erreurs, et il fait découvrir des notions que Python masque, comme les types vérifiés à la compilation, les pointeurs ou la programmation concurrente. Il ouvre aussi directement sur des métiers recherchés : développement de services en ligne, ingénierie de plateformes cloud, outillage de la sécurité et de l’exploitation (voir les métiers du développement). Sa documentation officielle, ses exemples exécutables dans le navigateur et la régularité du code d’un projet à l’autre facilitent l’apprentissage par la lecture de vrais programmes libres.

Sécurité de l’information

Le coin cyber

Go est l’un des langages que les agences de cybersécurité classent parmi les langages sûrs pour la mémoire. Il est aussi devenu un langage apprécié des attaquants. Les attaques sont décrites ici dans leur principe seulement.

C.1Un langage sûr pour la mémoire, avec deux réserves

Grâce à son ramasse-miettes, à la vérification des bornes des tableaux et à l’absence d’arithmétique des pointeurs, Go évite les dépassements de tampon et les utilisations après libération, causes principales des failles du C et du C++. Deux réserves : l’utilisation d’un pointeur nul provoque un arrêt brutal, qu’un attaquant peut déclencher à volonté si une donnée qu’il contrôle y conduit, et les courses de données restent possibles, avec des effets imprévisibles. D’où l’importance de tester avec le détecteur de courses et de prévoir, dans les serveurs, la reprise après un arrêt brutal d’une requête.

C.2Les modules et leur chaîne d’approvisionnement

Go a pris la sécurité des dépendances au sérieux : chaque module téléchargé est vérifié par son empreinte, inscrite dans le fichier go.sum et comparée à une base publique d’empreintes, tenue par Google sous forme de journal infalsifiable. Un module ne peut donc pas être modifié discrètement après publication. Cette protection n’empêche pas un attaquant de publier un module piégé sous un nom trompeur. En février 2025, des chercheurs ont découvert un module imitant une base de données très utilisée, publié en 2021 avec une porte dérobée : l’attaquant avait ensuite remplacé le code visible sur la forge par une version saine, mais le miroir de Go avait conservé la version piégée, distribuée pendant plus de trois ans. Il faut donc vérifier soigneusement le chemin exact de chaque module avant de l’ajouter, et utiliser govulncheck dans l’intégration continue.

C.3Go chez les attaquants

Les qualités qui font le succès de Go dans le cloud séduisent aussi les auteurs de logiciels malveillants : exécutables autonomes, compilation croisée pour Windows, Linux ou les objets connectés depuis un même code, et des fichiers volumineux, qui embarquent tout le moteur d’exécution, plus longs à analyser pour les outils de défense. De nombreuses familles de rançongiciels et de logiciels de prise de contrôle à distance sont écrites en Go (voir les logiciels malveillants). Les éditeurs de sécurité et les analystes ont dû adapter leurs outils pour démonter ces programmes.

C.4Idée reçue

« Mon serveur est écrit en Go, il est prêt pour la production. » Faux. La forme la plus simple du serveur Web de Go n’a aucun délai d’attente et peut être immobilisée par des clients volontairement lents (exercice 6). La sécurité d’un service dépend aussi de ses délais, de ses limites de taille de requête, de ses en-têtes de sécurité, de sa gestion des erreurs et de ses journaux, que le développeur doit configurer.

C.5Bonnes pratiques

Développeur

  • Toujours vérifier les erreurs ; ne jamais ignorer un err par facilité.
  • Lancer les tests avec le détecteur de courses ; protéger les données partagées.
  • Configurer les délais et les limites des serveurs ; utiliser html/template, qui échappe automatiquement les données, pour produire des pages Web.

Organisation

  • Exécuter govulncheck et go vet dans l’intégration continue ; mettre à jour Go régulièrement.
  • Vérifier le chemin exact et la réputation de chaque nouveau module ; garder go.sum sous gestion de versions.
  • Construire des images de conteneur minimales, avec l’exécutable seul.

Référentiels : équipe Go, Security Best Practices for Go Developers · CISA et partenaires internationaux, The Case for Memory Safe Roadmaps (2023) · OWASP (Open Worldwide Application Security Project), Go Secure Coding Practices.

Références

  1. A. A. A. Donovan, B. W. Kernighan, The Go Programming Language, Addison-Wesley, 2015.
  2. R. Pike, « Go at Google: Language Design in the Service of Software Engineering », conférence SPLASH, 2012.
  3. R. Cox, R. Griesemer, R. Pike, I. L. Taylor, K. Thompson, « The Go Programming Language and Environment », Communications of the ACM, vol. 65, n° 5, 2022.
  4. Équipe Go, The Go Programming Language Specification et notes de version de Go 1.26, 2026.
  5. K. Hockman, « Module Mirror and Checksum Database Launched », The Go Blog, 2019.

Voir aussi

Citer cet article

« Le langage Go », Encyclopédie informatique, révision du 26 octobre 2026.