WebSocket em Go: aplicações em tempo real do A ao Z

Introdução ao WebSocket em Go: por que tempo real?

As aplicações web modernas exigem cada vez mais entrega instantânea de dados. O tradicional modelo de requisição/resposta HTTP já não atende às necessidades de chats, jogos online, cotações de bolsa e painéis de monitoramento. É aqui que o WebSocket entra em cena — um protocolo que fornece uma conexão bidirecional contínua entre cliente e servidor. Neste artigo, vamos explorar como criar aplicações em tempo real com Go (Golang) usando WebSocket, desde a instalação até soluções de produção.

Go é ideal para WebSocket graças ao seu modelo leve de concorrência (goroutines) e alta performance. Vamos percorrer o caminho desde um simples servidor echo até um chat completo e um sistema de monitoramento.

Fundamentos do WebSocket e configuração do ambiente

O que é WebSocket?

WebSocket é um protocolo que opera sobre TCP. Ele começa com um handshake HTTP (upgrade), após o qual a conexão é convertida em um canal bidirecional permanente. Diferentemente do HTTP, o servidor pode enviar dados ao cliente sem solicitação — esta é a base do tempo real.

Instalação e bibliotecas

Go não possui uma biblioteca padrão para WebSocket, mas existe a popular biblioteca gorilla/websocket. Vamos instalá-la:

go get github.com/gorilla/websocket

Também é possível usar nhooyr.io/websocket (uma alternativa mais moderna), mas neste artigo vamos nos concentrar no gorilla por ser a mais difundida.

Primeiro servidor WebSocket em Go

Vamos escrever um servidor echo simples que recebe uma mensagem e a envia de volta:

package main

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

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

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

    for {        mt, message, err := conn.ReadMessage()        if err != nil {            log.Println("Read:", err)            break        }        log.Printf("Received: %s", message)        err = conn.WriteMessage(mt, message)        if err != nil {            log.Println("Write:", err)            break        }    }}

func main() {    http.HandleFunc("/echo", echoHandler)    log.Println("Server started on :8080")    log.Fatal(http.ListenAndServe(":8080", nil))}

Este é um exemplo funcional mínimo. Observe o Upgrader — ele verifica os cabeçalhos HTTP e faz a transição da conexão.

Arquitetura de aplicação em tempo real: chat em Go

Gerenciamento de conexões

Para um chat, é necessário gerenciar múltiplos clientes. Vamos criar uma estrutura Hub que armazenará todas as conexões ativas e distribuirá as mensagens:

type Client struct {    hub  *Hub    conn *websocket.Conn    send chan []byte}

type Hub struct {    clients    map[*Client]bool    broadcast  chan []byte    register   chan *Client    unregister chan *Client}

func newHub() *Hub {    return &Hub{        clients:    make(map[*Client]bool),        broadcast:  make(chan []byte),        register:   make(chan *Client),        unregister: make(chan *Client),    }}

func (h *Hub) run() {    for {        select {        case client := <-h.register:            h.clients[client] = true        case client := <-h.unregister:            if _, ok := h.clients[client]; ok {                delete(h.clients, client)                close(client.send)            }        case message := <-h.broadcast:            for client := range h.clients {                select {                case client.send <- message:                default: