Le langage Go
Partie 4 sur 4
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).
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.