WebSocket en Go : bibliothèque gorilla/websocket et implémentation standard

Bibliothèque WebSocket Go (Golang) : gorilla/websocket et le standard net/http

WebSocket est un protocole assurant une communication bidirectionnelle entre un client et un serveur sur une seule connexion TCP persistante. Contrairement au HTTP classique, une fois la connexion établie, les données peuvent être transmises dans les deux sens à tout moment, sans requêtes constantes du client. C'est une solution idéale pour les chats, les notifications en temps réel, les jeux en ligne et les plateformes de trading.

Dans l'écosystème Go (Golang), il existe plusieurs façons de travailler avec WebSocket. La plus populaire et éprouvée est la bibliothèque gorilla/websocket. Cependant, depuis Go 1.22, il est possible d'implémenter un serveur WebSocket de base sans dépendances externes, en utilisant le paquet standard net/http. Dans cet article, nous détaillerons les deux approches.

Installation de la bibliothèque gorilla/websocket

Pour commencer avec gorilla/websocket, installez-la via go get :

go get github.com/gorilla/websocket

La bibliothèque fournit une API pratique pour créer à la fois la partie serveur et la partie client. Elle gère la poignée de main (handshake), le tramage des messages, prend en charge la compression et le ping/pong automatique.

Serveur WebSocket avec gorilla/websocket

Considérons un exemple simple de serveur echo. Le client envoie un message, le serveur le renvoie :

package main

import (    "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 echoHandler(w http.ResponseWriter, r *http.Request) {    conn, err := upgrader.Upgrade(w, r, nil)    if err != nil {        log.Print("Upgrade failed:", err)        return    }    defer conn.Close()

    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Read error:", err)            break        }        log.Printf("Received: %s", message)

        if err := conn.WriteMessage(messageType, message); err != nil {            log.Println("Write error:", err)            break        }    }}

func main() {    http.HandleFunc("/echo", echoHandler)    log.Fatal(http.ListenAndServe(":8080", nil))}

Ici, Upgrader transforme une requête HTTP standard en connexion WebSocket. La fonction CheckOrigin contrôle les domaines autorisés à se connecter. En production, il est recommandé de vérifier des origines spécifiques.

Client WebSocket avec gorilla/websocket

Exemple de client qui se connecte à notre serveur et envoie un message :

package main

import (    "log"    "os"    "os/signal"    "time"    "github.com/gorilla/websocket")

func main() {    interrupt := make(chan os.Signal, 1)    signal.Notify(interrupt, os.Interrupt)

    url := "ws://localhost:8080/echo"    c, _, err := websocket.DefaultDialer.Dial(url, nil)    if err != nil {        log.Fatal("dial:", err)    }    defer c.Close()

    done := make(chan struct{})

    // Goroutine pour lire les réponses    go func() {        defer close(done)        for {            _, message, err := c.ReadMessage()            if err != nil {                log.Println("read:", err)                return            }            log.Printf("recv: %s", message)        }    }()

    // Envoi d'un message    ticker := time.NewTicker(time.Second)    defer ticker.Stop()

    for {        select {        case <-done:            return        case t := <-ticker.C:            err := c.WriteMessage(websocket.TextMessage, []byte(t.String()))            if err != nil {                log.Println("write:", err)                return            }        case <-interrupt:            log