WebSocket en Go: creación de aplicaciones en tiempo real desde cero

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

Las aplicaciones web modernas requieren cada vez más la transmisión instantánea de datos entre el cliente y el servidor. Las solicitudes HTTP tradicionales con su ciclo de "solicitud-respuesta" no son adecuadas para tareas donde la velocidad es importante: chats en línea, cotizaciones bursátiles, juegos multijugador o notificaciones en tiempo real. Aquí es donde WebSocket viene al rescate: un protocolo que proporciona una conexión bidireccional permanente. En este artículo, analizaremos cómo implementar WebSocket en Go (Golang), desde un servidor básico hasta una aplicación completa en tiempo real.

¿Qué es WebSocket y por qué Go?

WebSocket es un protocolo sobre TCP que permite establecer una conexión permanente entre el cliente (navegador) y el servidor. Después del handshake, los datos se transmiten en ambas direcciones sin encabezados HTTP adicionales, lo que reduce significativamente la latencia.

¿Por qué Go? El lenguaje Go es ideal para servidores WebSocket gracias a su soporte incorporado para concurrencia (gorutinas y canales), alto rendimiento y simplicidad para escribir código de red. A diferencia de Node.js, Go no requiere bucles de eventos externos, y su naturaleza compilada proporciona una ventaja en velocidad.

Servidor WebSocket básico en Go

Para trabajar con WebSocket en Go, utilizaremos la popular biblioteca gorilla/websocket. Proporciona una API conveniente y maneja los detalles del protocolo.

Instale la biblioteca:

go get github.com/gorilla/websocket

Ahora escribamos un servidor echo simple que devuelva todo lo que recibe del cliente.

package main

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

var upgrader = websocket.Upgrader{    CheckOrigin: func(r *http.Request) bool {        return true // Para desarrollo. En producción verifique el Origin.    },}

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

    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Read error:", err)            break        }        log.Printf("Recibido: %s", message)

        if err := conn.WriteMessage(messageType, message); err != nil {            log.Println("Write error:", err)            break        }    }}

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

Explicación del código:

• Upgrader — objeto que "actualiza" la conexión HTTP a WebSocket.
• CheckOrigin — función para verificar el origen de la solicitud. En producción, asegúrese de configurarla.
• conn.ReadMessage() y conn.WriteMessage() — métodos principales para leer/escribir mensajes.
• El bucle for mantiene la conexión abierta hasta que ocurra un error.

Arquitectura de un chat en tiempo real con WebSocket

El servidor echo es la base, pero para una aplicación en tiempo real, como un chat, se necesita una lógica más compleja. Consideremos una arquitectura donde varios clientes puedan intercambiar mensajes a través del servidor.

Componentes principales:

• Hub — administrador central que almacena la lista de conexiones activas.
• Client — estructura que representa una conexión WebSocket.
• Canales (channels) — para la transmisión segura de datos entre gorutinas.

package main

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

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

// Clien