WebSocket en Go : création d'applications temps réel de zéro

WebSocket en Go : création d'applications en temps réel

Les applications web modernes nécessitent de plus en plus souvent une transmission instantanée des données entre le client et le serveur. Les requêtes HTTP traditionnelles avec leur cycle « requête-réponse » ne conviennent pas aux tâches où la vitesse est importante : chats en ligne, cotations boursières, jeux multijoueurs ou notifications en temps réel. C'est là que WebSocket vient à la rescousse — un protocole assurant une connexion bidirectionnelle permanente. Dans cet article, nous allons voir comment implémenter WebSocket en Go (Golang), du serveur de base à une application temps réel complète.

Qu'est-ce que WebSocket et pourquoi Go ?

WebSocket est un protocole au-dessus de TCP qui permet d'établir une connexion permanente entre le client (navigateur) et le serveur. Après la poignée de main (handshake), les données sont transmises dans les deux sens sans en-têtes HTTP supplémentaires, ce qui réduit considérablement les latences.

Pourquoi Go ? Le langage Go est idéal pour les serveurs WebSocket grâce à sa prise en charge intégrée de la concurrence (goroutines et canaux), ses hautes performances et sa simplicité d'écriture de code réseau. Contrairement à Node.js, Go ne nécessite pas de boucles d'événements externes, et sa nature compilée offre un avantage en termes de vitesse.

Serveur WebSocket de base en Go

Pour travailler avec WebSocket en Go, nous utiliserons la bibliothèque populaire gorilla/websocket. Elle fournit une API pratique et gère les détails du protocole.

Installez la bibliothèque :

go get github.com/gorilla/websocket

Écrivons maintenant un simple serveur echo qui renvoie tout ce qu'il reçoit du client.

package main

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

var upgrader = websocket.Upgrader{    CheckOrigin: func(r *http.Request) bool {        return true // Pour le développement. En production, vérifiez l'Origin.    },}

func echoHandler(w http.ResponseWriter, r *http.Request) {    conn, err := upgrader.Upgrade(w, r, nil)    if err != nil {        log.Print("Échec de l'upgrade :", err)        return    }    defer conn.Close()

    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Erreur de lecture :", err)            break        }        log.Printf("Reçu : %s", message)

        if err := conn.WriteMessage(messageType, message); err != nil {            log.Println("Erreur d'écriture :", err)            break        }    }}

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

Explication du code :

• Upgrader — objet qui « élève » la connexion HTTP en WebSocket.
• CheckOrigin — fonction de vérification de l'origine de la requête. En production, configurez-la impérativement.
• conn.ReadMessage() et conn.WriteMessage() — méthodes principales pour lire/écrire des messages.
• La boucle for maintient la connexion ouverte jusqu'à l'apparition d'une erreur.

Architecture d'un chat temps réel avec WebSocket

Le serveur echo est une base, mais pour une application temps réel, comme un chat, une logique plus complexe est nécessaire. Examinons une architecture où plusieurs clients peuvent échanger des messages via le serveur.

Composants principaux :

• Hub — gestionnaire central stockant la liste des connexions actives.
• Client — structure représentant une connexion WebSocket.
• Canaux (channels) — pour la transmission sécurisée des données entre goroutines.

package main

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

var upgrader = websocket.Upgrader{    CheckOrigin: func(r *http.Request) bool { return true },}

// Clien