WebSockets em Go: Construindo uma aplicação em tempo real do zero

Por que Go e WebSockets são a combinação ideal para tempo real?

Imagine a seguinte situação: você está executando um chat online, um terminal de ações ou um jogo multijogador. Os usuários esperam uma resposta instantânea. Ninguém quer atualizar a página manualmente ou esperar 5 segundos até que a resposta do servidor chegue. É aqui que entram os WebSockets.

Go (Golang) é perfeito para esta tarefa. Suas goroutines leves permitem manter dezenas de milhares de conexões simultâneas sem perda de desempenho. E a biblioteca padrão net/http em conjunto com o pacote gorilla/websocket transforma a criação de aplicações em tempo real em puro prazer.

Neste artigo, vamos entender como o WebSocket funciona em Go, escrever um chat simples e discutir as melhores práticas. Vamos lá!

O que é WebSocket e por que ele é melhor que HTTP?

Resumidamente, WebSocket é um protocolo que estabelece uma conexão bidirecional permanente entre o cliente (navegador) e o servidor. Ao contrário do HTTP clássico, onde o cliente sempre inicia a requisição, o WebSocket permite que o servidor envie dados para o cliente a qualquer momento.

As vantagens são óbvias:

• Entrega instantânea — sem atrasos para estabelecer uma nova conexão.
• Menos tráfego — os cabeçalhos são enviados apenas uma vez durante o handshake.
• Eficiência — uma única conexão em vez de milhares de requisições HTTP.

Go lida muito bem com o gerenciamento dessas conexões. Em vez de criar threads do SO (o que é caro), Go usa goroutines. Uma goroutine — uma conexão. Milhares de goroutines trabalham em algumas threads do SO, consumindo o mínimo de memória.

Instalação e preparação do projeto em Go

Supondo que você já tenha o Go instalado. Se não — brew install go ou baixe de golang.org.

Vamos criar um novo módulo:

mkdir go-websocket-chatcd go-websocket-chatgo mod init go-websocket-chat

Agora vamos instalar a biblioteca mais popular gorilla/websocket:

go get github.com/gorilla/websocket

Pronto. Agora temos tudo para criar uma aplicação em tempo real em Go.

Escrevendo um servidor WebSocket em Go

Vamos começar com o mais simples — um servidor eco. O cliente envia uma mensagem, o servidor a retorna. Isso ajudará a entender a mecânica básica.

Passo 1: Estrutura e upgrade da conexão

A conexão WebSocket começa com uma requisição HTTP (handshake). O servidor deve "fazer o upgrade" para WebSocket. Em Go, isso é feito através de http.Hijacker ou através do método conveniente Upgrader do pacote gorilla/websocket.

Crie o arquivo main.go:

package main

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

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

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

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

        // Envia a mesma mensagem de volta        err = conn.WriteMessage(messageType, message)        if err != nil {            log.Println("Erro de escrita:", err)            break        }    }}

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

Execute: go run main.go