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

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

Les applications web modernes nécessitent de plus en plus souvent un transfert instantané de données entre le client et le serveur. Le modèle traditionnel requête-réponse HTTP ne convient pas pour les chats, les jeux en ligne, les plateformes de trading et la surveillance en temps réel. Le protocole WebSocket vient à la rescousse en établissant une connexion bidirectionnelle permanente. Dans cet article sur pythonlib.ru, nous allons voir comment créer une application temps réel en Go (Golang) en utilisant WebSocket.

Go est idéal pour cette tâche grâce à son support intégré de la concurrence (goroutines et canaux) et ses hautes performances. Ensemble, nous allons écrire un simple serveur WebSocket, implémenter un chat et examiner les problèmes typiques.

Qu'est-ce que WebSocket et pourquoi en a-t-on besoin en Go ?

WebSocket est un protocole fonctionnant au-dessus de TCP. Il est initié comme une requête HTTP (handshake), après quoi la connexion est "mise à niveau" vers un canal bidirectionnel permanent. Contrairement au long polling ou aux Server-Sent Events, WebSocket permet au serveur et au client d'envoyer des données à tout moment sans avoir à recréer la connexion.

Avantages de l'utilisation de WebSocket en Go :

• Concurrence : les goroutines gèrent facilement des milliers de connexions simultanées.
• Performance : consommation mémoire minimale par connexion.
• Simplicité : la bibliothèque standard net/http et le package gorilla/websocket rendent le code concis.

WebSocket est souvent utilisé dans :

• Les systèmes de chat et messageries instantanées
• Les éditeurs en ligne (Google Docs)
• Les terminaux de trading (cotations boursières)
• Les jeux et simulateurs

Installation et configuration de WebSocket en Go

Go n'a pas de support intégré pour WebSocket dans sa bibliothèque standard, mais il existe un excellent package gorilla/websocket. Installons-le :

go get github.com/gorilla/websocket

Créons un serveur HTTP minimal qui gérera les connexions WebSocket. Pour commencer, écrivons une fonction de gestion qui "met à niveau" la requête HTTP vers WebSocket.

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 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 des messages    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Erreur de lecture :", err)            break        }        log.Printf("Reçu : %s", message)

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

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

Ce code crée un simple serveur echo. Le client se connecte à ws://localhost:8080/ws et reçoit en retour tous les messages envoyés.

Création d'un chat temps réel en Go avec WebSocket

Maintenant, complexifions la tâche : faisons un chat où tous les clients connectés voient les messages des autres. Pour cela, nous aurons besoin de gérer la liste des connexions et de diffuser les messages.

Composants principaux :

• Hub — le gestionnaire central qui enregistre/supprime les clients et diffuse les messages.
• Clien