WebSocket em Go: criando aplicações em tempo real do zero

WebSocket em Go: criando aplicações em tempo real

As aplicações web modernas exigem cada vez mais a transmissão instantânea de dados entre cliente e servidor. As requisições HTTP tradicionais com seu ciclo de "requisição-resposta" não são adequadas para tarefas onde a velocidade é importante: chats online, cotações de bolsa, jogos multiplayer ou notificações em tempo real. É aqui que o WebSocket entra em ação — um protocolo que fornece uma conexão bidirecional permanente. Neste artigo, vamos explorar como implementar WebSocket em Go (Golang), desde um servidor básico até uma aplicação completa em tempo real.

O que é WebSocket e por que Go?

WebSocket é um protocolo sobre TCP que permite estabelecer uma conexão permanente entre o cliente (navegador) e o servidor. Após o handshake, os dados são transmitidos em ambas as direções sem cabeçalhos HTTP adicionais, reduzindo significativamente a latência.

Por que Go? A linguagem Go é ideal para servidores WebSocket devido ao suporte embutido para concorrência (goroutines e canais), alta performance e simplicidade na escrita de código de rede. Ao contrário do Node.js, Go não requer loops de eventos externos, e sua natureza compilada oferece vantagens em velocidade.

Servidor WebSocket básico em Go

Para trabalhar com WebSocket em Go, usaremos a biblioteca popular gorilla/websocket. Ela fornece uma API conveniente e lida com os detalhes do protocolo.

Instale a biblioteca:

go get github.com/gorilla/websocket

Agora vamos escrever um servidor echo simples, que envia de volta tudo o que recebe do cliente.

package main

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

var upgrader = websocket.Upgrader{    CheckOrigin: func(r *http.Request) bool {        return true // Para desenvolvimento. Em produção, verifique o Origin.    },}

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

    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Erro de leitura:", err)            break        }        log.Printf("Recebido: %s", message)

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

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

Explicação do código:

• Upgrader — objeto que "eleva" a conexão HTTP para WebSocket.
• CheckOrigin — função para verificar a origem da requisição. Em produção, configure-a obrigatoriamente.
• conn.ReadMessage() e conn.WriteMessage() — métodos principais para leitura/escrita de mensagens.
• O loop for mantém a conexão aberta até ocorrer um erro.

Arquitetura de um chat em tempo real com WebSocket

O servidor echo é a base, mas para uma aplicação em tempo real, como um chat, é necessária uma lógica mais complexa. Vamos considerar uma arquitetura onde vários clientes podem trocar mensagens através do servidor.

Componentes principais:

• Hub — gerenciador central que armazena a lista de conexões ativas.
• Client — estrutura que representa uma conexão WebSocket.
• Canais (channels) — para transmissão segura de dados entre goroutines.

package main

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

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

// Clien