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

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

As aplicações web modernas exigem cada vez mais a transmissão instantânea de dados entre cliente e servidor. O tradicional modelo de requisição-resposta HTTP não é adequado para chats, jogos online, plataformas de negociação e monitoramento em tempo real. O protocolo WebSocket vem para ajudar, estabelecendo uma conexão bidirecional permanente. Neste artigo no pythonlib.ru, vamos analisar como criar uma aplicação em tempo real com Go (Golang) usando WebSocket.

Go é ideal para esta tarefa devido ao suporte embutido para concorrência (goroutines e channels) e alta performance. Juntos, escreveremos um servidor WebSocket simples, implementaremos um chat e abordaremos problemas típicos.

O que é WebSocket e por que ele é necessário em Go?

WebSocket é um protocolo que opera sobre TCP. Ele é iniciado como uma requisição HTTP (handshake), após a qual a conexão é "atualizada" para um canal bidirecional permanente. Diferentemente de long polling ou Server-Sent Events, o WebSocket permite que servidor e cliente enviem dados a qualquer momento sem recriar a conexão.

Vantagens de usar WebSocket em Go:

• Concorrência: goroutines lidam facilmente com milhares de conexões simultâneas.
• Performance: consumo mínimo de memória por conexão.
• Simplicidade: a biblioteca padrão net/http e o pacote gorilla/websocket tornam o código conciso.

WebSocket é frequentemente usado em:

• Sistemas de chat e mensageiros
• Editores online (Google Docs)
• Terminais de negociação (cotações de bolsa)
• Jogos e simuladores

Instalação e configuração do WebSocket em Go

Go não possui suporte embutido para WebSocket na biblioteca padrão, mas existe um excelente pacote gorilla/websocket. Vamos instalá-lo:

go get github.com/gorilla/websocket

Vamos criar um servidor HTTP mínimo que atenderá conexões WebSocket. Primeiro, escrevemos uma função handler que "atualiza" a requisição HTTP para WebSocket.

package main

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

var upgrader = websocket.Upgrader{    CheckOrigin: func(r *http.Request) bool {        return true // permite todas as origens (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 de mensagens    for {        messageType, message, err := conn.ReadMessage()        if err != nil {            log.Println("Erro na leitura:", err)            break        }        log.Printf("Recebido: %s", message)

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

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

Este código cria um servidor echo simples. O cliente se conecta a ws://localhost:8080/ws e recebe de volta todas as mensagens enviadas.

Criando um chat em tempo real em Go com WebSocket

Agora vamos complicar a tarefa: faremos um chat onde todos os clientes conectados veem as mensagens uns dos outros. Para isso, precisaremos gerenciar a lista de conexões e transmitir as mensagens.

Componentes principais:

• Hub — gerenciador central que registra/remove clientes e transmite mensagens.
• Clien