Bibliothèque WebSocket Gorilla pour Go (Golang) : guide complet

Gorilla WebSocket : un outil puissant pour le temps réel en Go

Dans le développement web moderne, le besoin d'échanger des données en temps réel devient de plus en plus crucial. Qu'il s'agisse de chats, de jeux en ligne, de surveillance de serveurs ou de cotations boursières — WebSocket est le standard de facto pour la communication bidirectionnelle entre le client et le serveur. Pour le langage Go (Golang), l'une des bibliothèques les plus populaires et stables pour travailler avec WebSocket est Gorilla WebSocket.

La bibliothèque gorilla/websocket fait partie de l'écosystème Gorilla Toolkit — un ensemble de paquets de haute qualité pour le développement web en Go. Elle fournit un ensemble complet de fonctionnalités pour créer des serveurs et clients WebSocket, prend en charge tous les protocoles principaux (RFC 6455) et se distingue par sa simplicité d'utilisation.

Fonctionnalités principales de Gorilla WebSocket

• Prise en charge complète du protocole WebSocket — travail avec des trames textuelles et binaires, fragmentation des messages, trames de contrôle (ping/pong).
• API pratique — interface minimaliste avec les fonctions ReadMessage et WriteMessage.
• Prise en charge de TLS/SSL — connexions WebSocket sécurisées (wss://).
• Configuration flexible — possibilité de définir des délais d'attente, des tailles de tampons, de vérifier l'origine des requêtes.
• Compatibilité avec HTTP — s'intègre facilement avec tout serveur HTTP Go (net/http).
• Travail avec les contextes — prise en charge de context.Context pour l'annulation des opérations.

Installation de la bibliothèque

Pour installer Gorilla WebSocket, exécutez la commande dans le terminal :

go get github.com/gorilla/websocket

Ensuite, ajoutez l'import dans votre fichier Go :

import "github.com/gorilla/websocket"

Exemple de base d'un serveur WebSocket

Considérons un serveur echo très simple qui accepte les connexions WebSocket et renvoie les messages reçus.

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("Échec de la mise à niveau :", 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("/echo", echoHandler)    log.Println("Serveur démarré sur :8080")    log.Fatal(http.ListenAndServe(":8080", nil))}

Explication détaillée du code

1. Upgrader — est une structure qui transforme une requête HTTP standard en connexion WebSocket. Dans l'exemple, nous autorisons les requêtes de toutes les origines (champ CheckOrigin). En production, il convient de vérifier des domaines spécifiques.
2. Upgrade — la méthode principale qui prend http.ResponseWriter et *http.Request et retourne *websocket.Conn.
3. ReadMessage — un appel bloquant qui attend un nouveau message du client. Il retourne le type de message (texte ou données binaires) et les données elles-mêmes.
4. WriteMessage — envoie un message au client. Dans ce cas, nous renvoyons simplement ce que nous avons reçu.

Client WebSocket (Gorilla)

La bibliothèque permet également