Biblioteca WebSocket Gorilla para Go | Guía

Biblioteca Gorilla WebSocket para Go (Golang)

Gorilla WebSocket es una de las bibliotecas más populares y estables para trabajar con el protocolo WebSocket en el lenguaje Go (Golang). Forma parte del ecosistema Gorilla Toolkit y proporciona a los desarrolladores una herramienta potente, flexible y de alto rendimiento para crear aplicaciones en tiempo real: chats, notificaciones en vivo, juegos en línea, paneles de monitoreo y mucho más.

La biblioteca implementa completamente la especificación RFC 6455, admite tanto el lado del servidor como el del cliente, y maneja automáticamente la fragmentación de mensajes, los mecanismos ping/pong y el control de la conexión. Gorilla WebSocket está escrita en Go puro sin dependencias externas, lo que la hace ligera y rápida.

Características principales

Soporte completo del protocolo WebSocket (RFC 6455).
API simple e intuitiva.
Soporte para mensajes de texto y binarios.
Gestión automática de ping/pong para mantener la conexión.
Posibilidad de verificar el origen de la solicitud (Origin).
Soporte para compresión de mensajes (permessage-deflate).
Funciona con TLS/HTTPS.
Alto rendimiento y bajo consumo de memoria.

Instalación

Para instalar la biblioteca, ejecute el comando:

go get github.com/gorilla/websocket

Luego, importe el paquete en su código:

import "github.com/gorilla/websocket"

Ejemplo de servidor WebSocket en Go

A continuación se muestra un servidor simple que acepta conexiones WebSocket y envía de vuelta los mensajes recibidos (servidor eco):

package main

import (    "fmt"    "log"    "net/http"

    "github.com/gorilla/websocket")

var upgrader = websocket.Upgrader{    CheckOrigin: func(r *http.Request) bool {        return true // Permitimos todos los orígenes (para desarrollo)    },}

func echoHandler(w http.ResponseWriter, r *http.Request) {    // Establecemos la conexión WebSocket    conn, err := upgrader.Upgrade(w, r, nil)    if err != nil {        log.Print("Error de actualización:", err)        return    }    defer conn.Close()

    // Bucle infinito de lectura de mensajes    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Error de lectura:", err)            break        }        log.Printf("Mensaje recibido: %s", message)

        // Enviamos el mensaje de vuelta        err = conn.WriteMessage(messageType, message)        if err != nil {            log.Println("Error de escritura:", err)            break        }    }}

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

Cliente WebSocket en Go

Ejemplo de un cliente simple que se conecta al servidor y envía un mensaje:

package main

import (    "fmt"    "log"    "net/url"

    "github.com/gorilla/websocket")

func main() {    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/echo"}    fmt.Printf("Conectando a %s", u.String())

    conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)    if err != nil {        log.Fatal("Error de conexión:", err)    }    defer conn.Close()

    // Enviamos un mensaje de texto    err = conn.WriteMessage(websocket.TextMessage, []byte("¡Hola, WebSocket!"))    if err != nil {        log.Fatal("Error de envío:", err)    }

    // Leemos la respuesta    _, message, err := conn.ReadMessage()    if err != nil {        log.Fatal("Error de lectura:", err)    }    fmt.Printf("Respuesta recibida: %s", message)}