WebSocket en Go: creación de aplicaciones en tiempo real con Golang

WebSocket en Go: creación de aplicaciones en tiempo real con Golang

Las aplicaciones web modernas requieren cada vez más una transferencia instantánea de datos entre el cliente y el servidor. La tradicional solicitud-respuesta HTTP no es adecuada para chats, juegos en línea, plataformas de trading y monitoreo en tiempo real. El protocolo WebSocket viene al rescate, estableciendo una conexión bidireccional permanente. En este artículo en pythonlib.ru, analizaremos cómo crear una aplicación en tiempo real con Go (Golang) utilizando WebSocket.

Go es ideal para esta tarea gracias a su soporte incorporado para concurrencia (gorutinas y canales) y su alto rendimiento. Juntos escribiremos un servidor WebSocket simple, implementaremos un chat y veremos problemas típicos.

¿Qué es WebSocket y por qué es necesario en Go?

WebSocket es un protocolo que funciona sobre TCP. Se inicia como una solicitud HTTP (handshake), después de lo cual la conexión se "actualiza" a un canal bidireccional permanente. A diferencia de long polling o Server-Sent Events, WebSocket permite que el servidor y el cliente envíen datos en cualquier momento sin tener que recrear la conexión.

Ventajas de usar WebSocket en Go:

• Concurrencia: las gorutinas manejan fácilmente miles de conexiones simultáneas.
• Rendimiento: consumo mínimo de memoria por cada conexión.
• Simplicidad: la biblioteca estándar net/http y el paquete gorilla/websocket hacen que el código sea conciso.

WebSocket se usa a menudo en:

• Sistemas de chat y mensajería
• Editores en línea (Google Docs)
• Terminales de trading (cotizaciones bursátiles)
• Juegos y simuladores

Instalación y configuración de WebSocket en Go

Go no tiene soporte incorporado para WebSocket en la biblioteca estándar, pero existe un excelente paquete gorilla/websocket. Lo instalaremos:

go get github.com/gorilla/websocket

Crearemos un servidor HTTP mínimo que manejará conexiones WebSocket. Para empezar, escribiremos una función manejadora que "actualice" la solicitud HTTP a WebSocket.

package main

import (    "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 handleWebSocket(w http.ResponseWriter, r *http.Request) {    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("Recibido: %s", message)

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

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

Este código crea un servidor eco simple. El cliente se conecta a ws://localhost:8080/ws y recibe de vuelta todos los mensajes enviados.

Creación de un chat en tiempo real en Go con WebSocket

Ahora complicaremos la tarea: haremos un chat donde todos los clientes conectados vean los mensajes de los demás. Para ello, necesitaremos gestionar la lista de conexiones y difundir los mensajes.

Componentes principales:

• Hub — el gestor central que registra/elimina clientes y difunde mensajes.
• Client — representa una conexión individual.