live-platform

Uma chamada no navegador que compartilha tela, voz e câmera a partir de um link, servida por um único binário Go com seu próprio servidor de mídia WebRTC.

Go · TypeScriptversatile.shcódigo aberto (GPL-3.0-or-later)Servidor Go 1.27.4, Pion SFU, gnetCliente React 19, Vite, Tailwind 4Licença GPL-3.0-or-laterUnidade de deploy um contêiner, sem banco de dadosgithub.com/versatile-sh/live-platform
sfu

Visão geral

O live-platform é uma chamada no navegador para quem precisa mostrar algo a alguém agora: uma sessão de pair programming, uma olhada rápida numa tela, uma chamada com um amigo que não tem conta em lugar nenhum. A sala é o endereço, e quem abre um nome livre é o dono daquela sala. Sem conta, nada para instalar.

Um processo Go serve a página, a sinalização e a sua própria unidade de encaminhamento seletivo (SFU) construída sobre o Pion. A mídia não passa por um serviço hospedado nem usa uma malha peer-to-peer, em que cada pessoa enviaria uma cópia por ouvinte.

Ele é deliberadamente restrito. Não é um produto de gravação ou transcrição, e ainda não tem criptografia de ponta a ponta. A seção de segurança lista o que está e o que não está construído.

FatoValor
Tamanho da salaAté 10 pessoas
Liberação da sala30 segundos depois que a última pessoa sai
AcessoPública (link) ou privada (código da sala); qualquer uma pode aparecer no lobby
MídiaMicrofone, câmera, tela com seu som, push to talk, desfoque de fundo
ExtrasChat, mão levantada, lousa Excalidraw, controles do dono
IdiomasInglês e português, conforme o navegador

Rodar

Precisa de Go 1.27.4, Node.js 26 e um navegador com WebRTC. Dois terminais; o servidor de desenvolvimento do Vite faz proxy de /api para 127.0.0.1:8080 e de /ws para 127.0.0.1:8081.

Desenvolvimentosh
cd server
PUBLIC_ORIGIN=http://localhost:5173 go run ./cmd/live

cd web
npm ci
npm run dev        # http://localhost:5173

Abra http://localhost:5173/any-name em duas abas para testar uma chamada. Para servir tudo de um único binário:

Binário únicosh
cd web && npm ci && npm run build
cd ../server && CGO_ENABLED=0 go build -trimpath -o live ./cmd/live
WEB_DIR=../web/dist ./live        # page and API on :8080; GET /up answers 200

Sem WEB_DIR o servidor responde apenas a API. A página e a sinalização usam portas diferentes, então diante de um navegador as duas precisam ficar atrás de uma única origem. O Dockerfile gera um binário estático sobre distroless, sem root, com PORT=3000, SIGNAL_PORT=3001 e WEB_DIR=/web.

Verificaçõessh
mise install        # pinned Go, golangci-lint, vlint, revive
lefthook install    # fast lint on commit, changed-package lint on push
mise run check      # lint-full, race tests, Semgrep
mise run test       # go test -race -count=1 ./...
cd web && npx vitest run
cd web && npm run test:live   # client against a real server
VariávelPadrãoEfeito
PORT8080 (3000 na imagem)HTTP: página, API e /up
SIGNAL_PORT8081 (3001 na imagem)WebSocket de sinalização em /ws
PUBLIC_ORIGINvazioOrigens autorizadas a abrir o socket; vazio permite só o host da própria requisição
WEB_DIRvazio (/web na imagem)Cliente compilado; vazio serve só a API
WEB_LIVE_DIRvazioDiretório sobreposto a WEB_DIR para servir um cliente mais novo sem reiniciar
MEDIAonoff roda presença e chat sem o SFU
MEDIA_UDP_PORT0Uma porta UDP compartilhada para toda a mídia; 0 deixa cada conexão escolher a sua
MEDIA_PUBLIC_IPvazioEndereço anunciado aos navegadores atrás de NAT
HANDOVER_DIRvazioDiretório compartilhado com o próximo processo em reinícios planejados
AUDIT_DIRvazioDiretório da trilha de auditoria; vazio a desliga
AUDIT_RETENTION_DAYS183Dias de arquivos de auditoria mantidos
OTEL_EXPORTER_OTLP_ENDPOINTvazioColetor OTLP/HTTP; vazio desliga o tracing

Tudo é lido do ambiente uma única vez, na partida. Um valor que não pode ser interpretado para o servidor e nomeia a configuração.

Arquitetura

Um binário, três listeners. O HTTP serve o cliente compilado e uma pequena API JSON. Um event loop do gnet carrega o WebSocket lv.1. O Pion carrega a mídia por UDP com DTLS-SRTP, direto entre navegador e servidor.

text
Browser (React 19)                     live (one Go process)
+----------------------+  HTTPS        +---------------------------+
| pages and stores     |-------------->| net/http   page, /api     |
|                      |  WSS /ws      +---------------------------+
|                      |-------------->| gnet + gobwas/ws  lv.1    |
|                      |               |        |                  |
|                      |               |  presence hub             |
|                      |               |  one actor per room       |
|                      |               |        |                  |
| publish PeerConn     |  UDP, DTLS    |  Pion SFU                 |
| subscribe PeerConn   |<=============>|                           |
+----------------------+  SRTP         +---------------------------+
ListenerBibliotecaCarrega
HTTP (PORT)net/httpcliente, GET /api/rooms/{slug}, /api/lobby, /api/project, /api/pass/{id}, /up
Sinalização (SIGNAL_PORT)gnet + gobwas/wslv.1: presença, chat, lousa, ações do dono, SDP e ICE
Mídia (MEDIA_UDP_PORT)Pion WebRTCRTP sobre DTLS-SRTP

O servidor segue portas e adaptadores, com as dependências apontando para dentro.

text
server/
  cmd/live/            binary; `live audit` reads the audit trail
  app/                 composition root: env read and checked once
  core/room/           Room aggregate. Pure: no clock, no I/O
  port/inbound|outbound/
  service/presence/    hub + one goroutine per room
  signal/              lv.1 over WebSocket on gnet
  httpapi/  page/      JSON routes; client with security headers
  sfu/                 Pion media engine
  handoff/  audit/  guestpass/  clientinfo/  github/

O cliente vive em web/src, uma pasta por responsabilidade: room, media, signal, session, lobby, board, domain, ui, i18n. Não usa router nem biblioteca de estado; três páginas e um store por responsabilidade não precisam deles.

Fluxo de entrada

linkseat
Um link é um ingresso: o convidado passa pela porta, a sala reserva um assento e todos lá dentro são avisados.
  1. 1Abrir o socketO navegador abre o WebSocket lv.1 e envia join. O socket aceita apenas as origens configuradas.
  2. 2Reservar um assentoO servidor de sinalização entrega o frame ao hub de presença. O ator da sala reserva um assento.
  3. 3Receber o estadoO navegador recebe joined com seu assento, geração e segredo de retomada, depois o roster inteiro com um número de versão.
  4. 4Negociar a publicaçãoO navegador envia seu SDP offer pelo mesmo socket num frame rtc. O hub negocia com o SFU a conexão de publicação.
  5. 5Enviar mídiaA mídia vai direto ao SFU por UDP. O SFU encaminha os pacotes, sem decodificar, para todos os outros.
  6. 6Difundir mudançasCada mudança na sala envia a todos um novo roster completo.

Cada participante mantém duas conexões peer: uma publica, a outra recebe todos os demais. Os tracks encaminhados são nomeados por quem os enviou e o que são (microfone, câmera, tela, som da tela), a partir das fontes que o publicador declarou.

Presença

roster4 s?hereunsureheld
O roster é do servidor: um convidado quieto vira instável, um que recarrega mantém o assento retido e um timer decide quem é removido.

O servidor é a única autoridade sobre quem está numa sala. Os navegadores só informam. Ele observa três sinais: o socket, um heartbeat e o caminho de mídia.

  1. 1Primeiro sinal perdidoOs outros veem o participante como instável.
  2. 2Após 4 segundos de tolerânciaO participante aparece como reconectando.
  3. 3Sem retornoO participante é removido. Sair de propósito é imediato.

Recarregar mantém o assento. O navegador guarda um segredo por sala durante a vida da aba e o apresenta para retomar. O segredo gira a cada retomada e o antigo é recusado.

Num reinício planejado, o servidor que está parando pode escrever suas salas em HANDOVER_DIR. O novo processo as adota e retém cada assento por 12 segundos enquanto os navegadores reconectam. Um crash perde as salas.

Modelo de sala

Toda mudança numa sala passa pelo seu ator, em ordem, então não há locks em volta do estado da sala. O agregado Room em core/room recebe a hora e responde com o que mudou. Ele não tem relógio nem I/O, então cada regra de presença é um teste unitário simples.

  • Os assentos são um bitmap uint64.
  • O que um participante tem ligado (microfone, câmera, tela, áudio da tela, mão, dono, instável) é um uint16 de flags.
  • Os rosters são enviados inteiros, com número de versão, nunca como diff. Um navegador que perdeu uma mensagem fica certo de novo na seguinte.
  • Cada sala publica um resumo atômico, então listar o lobby nunca bloqueia na goroutine de uma sala.

A derivação do código da sala em salas privadas é tratada em Segurança. O agregado da sala guarda as regras do dono: transferir, remover, banir, silenciar todos, falar por mão levantada, mudanças de acesso e de listagem.

Protocolo lv.1

Frames de texto JSON sobre um WebSocket, cada um com seu tipo em t.

DireçãoFrames
Navegador para servidorjoin, resume, hb, leave, media, rtc, look, photo, chat, board, owner, remove, ban, transfer, listed, password
Servidor para navegadorjoined, roster (versionado, inteiro), rtc, chat, photo, board, error

Os códigos de fechamento da aplicação dizem ao navegador por que um socket terminou.

CódigoSignificado
4001Substituído por outra aba
4012Servidor reiniciando
4400Frame inválido
4401Sem hello
4403Removido
4404Banido
4408Silencioso
4409Lento demais para ler
4429Inundação

Limites de sinalização: 128 KiB por frame, 2 MiB de dados não enviados, 20 frames por segundo com rajada de 80. Um cliente que os ultrapassa é desconectado com um código que diz o motivo.

Caminho da mídia

sfu
O SFU é uma agência dos correios: cada track que um convidado envia é encaminhado, sem abrir, a todos os outros convidados.
  • O SFU encaminha RTP sem decodificar.
  • Os codecs são os padrões do Pion. O servidor pede aos publicadores um keyframe a cada 2 segundos para quem entra tarde ver imagem rápido.
  • Sem simulcast e sem encaminhamento sob demanda: cada stream vai a todos na qualidade em que foi enviado.
  • O processamento de áudio roda só no navegador: RNNoise para o filtro de voz mais forte, além de ganho, noise gate e cancelamento de eco. O desfoque de fundo roda o MediaPipe no navegador.
  • Uma porta UDP para toda a mídia quando MEDIA_UDP_PORT está definido, anunciada em MEDIA_PUBLIC_IP.
  • Não há relay TURN, então uma rede que bloqueia UDP não consegue transportar mídia.

Como cada stream é encaminhado para todos os outros participantes, o upload do servidor cresce com o quadrado do tamanho da sala. O teto de 10 por sala o limita.

A lousa é o Excalidraw, fixado numa versão e carregado só quando aberto. Ela vive nos navegadores; o servidor repassa suas peças sem lê-las e não guarda nada.

Modelo de segurança

Numa sala privada, o navegador deriva 64 bytes do código da sala com PBKDF2-SHA-256 a 600.000 iterações, usando o endereço da sala como salt. Os primeiros 32 bytes são um verificador enviado ao servidor, que guarda apenas o seu SHA-256. Os outros 32 ficam reservados como chave de mídia e nunca saem do navegador. Um link compartilhado leva o código depois do #, que os navegadores não enviam. Dez tentativas erradas trancam a porta por cinco minutos.

  • CSP: default-src 'none', scripts, estilos, fontes e conexões da própria origem, sem script nem estilo inline. 'wasm-unsafe-eval' é permitido para o filtro de voz e o desfoque.
  • Cadeia de suprimentos: versões exatas, lockfiles versionados, scripts de instalação do npm desativados, imagens base e actions de CI fixadas por digest, Dependabot, govulncheck, go mod verify, npm audit e um SBOM CycloneDX para servidor e cliente.
  • Imagem: distroless, estática, sem root.
  • Auditoria: sem AUDIT_DIR o servidor não registra nada. Com ele, uma linha JSON por fato vai para um arquivo diário, apagado após AUDIT_RETENTION_DAYS. O texto do chat de uma sala pública é registrado; o chat de uma sala privada guarda só quem, quando e o tamanho.
  • Os spans de tracing levam o nome da sala e flags, nunca um endereço, um nome ou texto de chat.

Sem criptografia de ponta a ponta. A mídia é criptografada entre cada navegador e o servidor (DTLS-SRTP) e o servidor poderia lê-la. O chat, as mensagens privadas e a lousa passam pelo servidor em claro.

Decisões

DecisãoEscolhidoRejeitadoPor quê
Topologia de mídiaSFU próprio sobre o Pion para toda salaMalha; SFU hospedadoUma malha custa a cada pessoa um upload por ouvinte; um SFU hospedado coloca a mídia no servidor de outra pessoa.
SinalizaçãoEvent loop do gnetWebSocket simples do net/httpSegura muitos sockets ociosos de forma barata. Carrega só sinalização.
Página e APInet/httpUm frameworkNada aqui precisa de mais.
Estado do clienteSem router, sem biblioteca de estadoRouter e store globalTrês páginas e um store por responsabilidade não precisam deles.
Estado da salaUm ator por salaEstado compartilhado com locksMudanças ordenadas, agregado puro, testes unitários simples.
Sincronização do rosterRoster inteiro, versionadoDiffsUma mensagem perdida se corrige na seguinte.
  • Ainda sem criptografia de ponta a ponta; a chave de mídia derivada fica reservada para ela.
  • Sem relay TURN: redes que bloqueiam UDP ficam sem mídia.
  • Sem simulcast nem encaminhamento sob demanda: streams ocultos ainda chegam ao cliente.
  • As salas sobrevivem apenas a um handover planejado, não a um crash.
  • Não construído: gravação, transcrição, extensões.

Arquivos