Go Academy · Aula

Gerenciamento de conexões

Trate desconexões

Gerenciamento de conexões é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

As conexões não duram para sempre

Os clientes fecham abas, perdem a conexão Wi-Fi ou falham. Servidores WebSocket robustos precisam detectar desconexões, liberar recursos e encerrar gorrotinas. Caso contrário, você vazará memória e sockets.

O handshake de fechamento

Um encerramento limpo envia um quadro de fechamento nas duas direções. A gorilla apresenta isso como um erro retornado por ReadMessage, com um código de fechamento que você pode inspecionar.

if websocket.IsCloseError(err, websocket.CloseNormalClosure) {
    // graceful close
}

Keepalive com Ping/Pong

Para detectar uma conexão parcialmente aberta (quando o par desaparece sem fechar), o servidor envia periodicamente quadros de controle ping e espera respostas pong.

conn.SetPongHandler(func(string) error {
    conn.SetReadDeadline(time.Now().Add(60 * time.Second))
    return nil
})

Prazos de leitura

Defina um prazo de leitura para que um par inativo eventualmente gere um erro, em vez de bloquear para sempre. Atualize o prazo sempre que um pong chegar.

conn.SetReadDeadline(time.Now().Add(60 * time.Second))

O ticker de ping

Um ticker na gorrotina de escrita dispara pings periódicos. Se uma escrita falhar, a conexão está inativa e você encerra a gorrotina.

ticker := time.NewTicker(54 * time.Second)
defer ticker.Stop()
for range ticker.C {
    if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
        return
    }
}

Limpeza ao sair

Quando um loop de leitura ou escrita termina, cancele o registro do cliente e feche a conexão. defer torna isso confiável mesmo em caso de panic.

defer func() {
    hub.unregister <- client
    conn.Close()
}()

Duas gorrotinas por conexão

O padrão comum executa uma readPump e uma writePump por conexão. Quando uma detecta um erro, ela aciona a limpeza que interrompe a outra (geralmente fechando o canal de envio).

Prazos de escrita também

Defina prazos de escrita para que uma escrita travada não mantenha uma gorrotina bloqueada para sempre. Uma escrita que excede o prazo retorna um erro, e você encerra a conexão.

conn.SetWriteDeadline(time.Now().Add(10 * time.Second))

Encerramento ordenado do servidor

Ao encerrar o servidor, envie um quadro de fechamento a cada cliente e aguarde brevemente. Combine isso com http.Server.Shutdown e um prazo de contexto.

conn.WriteMessage(websocket.CloseMessage,
    websocket.FormatCloseMessage(websocket.CloseGoingAway, "bye"))

Reconexão no cliente

Desconexões são normais. Os clientes devem implementar uma lógica de reconexão com espera crescente exponencial. No lado do servidor, basta tratar cada conexão e desconexão corretamente.

Executável: analogia da detecção de prazo

O keepalive de WebSocket precisa da biblioteca; este programa da biblioteca padrão modela uma verificação de atividade baseada em prazo usando um temporizador e um canal.

package main

import (
    "fmt"
    "time"
)

func main() {
    pong := make(chan struct{})
    go func() {
        time.Sleep(20 * time.Millisecond) // simulate a slow/absent peer
        _ = pong                          // no pong sent -> dead connection
    }()
    select {
    case <-pong:
        fmt.Println("alive")
    case <-time.After(10 * time.Millisecond):
        fmt.Println("no pong: closing dead connection")
    }
}

Verificação rápida

Teste sua compreensão do gerenciamento de conexões.

Recapitulação

Você aprendeu sobre o gerenciamento de conexões:

Trate o handshake de fechamento e inspecione os códigos de fechamento
Use ping/pong junto com prazos de leitura e escrita para detectar pares inativos
Execute os pumps de leitura e escrita; faça a limpeza com defer
Encerre o servidor de forma ordenada com quadros de fechamento; os clientes se reconectam usando espera crescente

Perguntas Frequentes

A aula “Gerenciamento de conexões” é grátis?

Sim — o texto completo de “Gerenciamento de conexões” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Gerenciamento de conexões”?

Trate desconexões Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Gerenciamento de conexões”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy