WebSockets en Go : Créer une application en temps réel de zéro

Pourquoi Go et les WebSockets sont-ils le tandem idéal pour le temps réel ?

Imaginez la situation : vous lancez un chat en ligne, un terminal boursier ou un jeu multijoueur. Les utilisateurs attendent une réaction instantanée. Personne ne veut actualiser la page manuellement ou attendre 5 secondes que la réponse du serveur arrive. C'est là que les WebSockets entrent en scène.

Go (Golang) est parfaitement adapté à cette tâche. Ses goroutines légères permettent de maintenir des dizaines de milliers de connexions simultanées sans perte de performance. Et la bibliothèque standard net/http associée au package gorilla/websocket transforme l'écriture d'applications en temps réel en un pur plaisir.

Dans cet article, nous allons comprendre comment fonctionne WebSocket en Go, écrire un chat simple et discuter des bonnes pratiques. C'est parti !

Qu'est-ce que WebSocket et en quoi est-il meilleur que HTTP ?

En bref, WebSocket est un protocole qui établit une connexion bidirectionnelle permanente entre le client (navigateur) et le serveur. Contrairement au HTTP classique où le client initie toujours la requête, WebSocket permet au serveur d'envoyer lui-même des données au client à tout moment.

Les avantages sont évidents :

• Livraison instantanée — pas de délais pour établir une nouvelle connexion.
• Moins de trafic — les en-têtes ne sont envoyés qu'une seule fois lors de la poignée de main.
• Efficacité — une seule connexion au lieu de milliers de requêtes HTTP.

Go gère parfaitement ces connexions. Au lieu de multiplier les threads du système d'exploitation (ce qui est coûteux), Go utilise des goroutines. Une goroutine — une connexion. Des milliers de goroutines fonctionnent sur quelques threads du système d'exploitation, consommant un minimum de mémoire.

Installation et préparation du projet en Go

Supposons que Go soit déjà installé. Sinon — brew install go ou téléchargez-le depuis golang.org.

Créons un nouveau module :

mkdir go-websocket-chatcd go-websocket-chatgo mod init go-websocket-chat

Installons maintenant la bibliothèque la plus populaire gorilla/websocket :

go get github.com/gorilla/websocket

Prêt. Nous avons maintenant tout ce qu'il faut pour créer une application en temps réel en Go.

Écrire un serveur WebSocket en Go

Commençons par le plus simple — un serveur d'écho. Le client envoie un message, le serveur le renvoie. Cela permettra de comprendre la mécanique de base.

Étape 1 : Structure et mise à niveau de la connexion

La connexion WebSocket commence par une requête HTTP (poignée de main). Le serveur doit « mettre à niveau » cette connexion vers WebSocket. En Go, cela se fait via http.Hijacker ou via la méthode pratique Upgrader du package gorilla/websocket.

Créez le fichier main.go :

package main

import (    "fmt"    "log"    "net/http"    "github.com/gorilla/websocket")

var upgrader = websocket.Upgrader{    CheckOrigin: func(r *http.Request) bool {        return true // autoriser toutes les origines (pour le développement)    },}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {    conn, err := upgrader.Upgrade(w, r, nil)    if err != nil {        log.Print("Erreur de mise à niveau :", err)        return    }    defer conn.Close()

    // Boucle infinie de lecture et d'écriture    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Erreur de lecture :", err)            break        }        log.Printf("Reçu : %s", message)

        // Renvoyer le même message        err = conn.WriteMessage(messageType, message)        if err != nil {            log.Println("Erreur d'écriture :", err)            break        }    }}

func main() {    http.HandleFunc("/ws", handleWebSocket)    fmt.Println("Serveur démarré sur :8080")    log.Fatal(http.ListenAndServe(":8080", nil))}

Lancez : go run main.go