Controle quem se conecta e assina usando suas regras de sessão existentes.
Entregue atualizações privadas de pedidos, alertas de conta e eventos do espaço de trabalho a clientes web e móveis sem expor credenciais do backend no código do cliente. Seu próprio endpoint de autenticação verifica a sessão de quem chama e assina as inscrições em canais privados ou de presença por conexão, enquanto a criptografia de ponta a ponta protege payloads sensíveis antes que saiam do seu servidor.
auth.ts
200 · assinado403 · Forbidden200 · assinado200 · assinado// Your endpoint. The only place the app secret lives.app.post("/bird/auth", async (req, res) => { const { connection_id, channel_name } = req.body; const user = await session(req); if (!mayJoin(user, channel_name)) return res.sendStatus(403); // Signs <connection_id>:<channel_name>[:<member_data>] with the app // secret, and adds shared_secret on an encrypted channel. res.json( await bird.realtime.authorizeChannel({ connectionId: connection_id, channelName: channel_name, memberData: JSON.stringify({ member_id: user.id, member_info: { name: user.name }, }), }), );});
POST/bird/auth
Corpo da resposta
{ "auth": "d0e95a856ddc1b09d4c8:8f9a2c71e4…", "member_data": "{\"member_id\":\"u_42\",\"member_info\":{\"name\":\"Maya Chen\"}}" }
auth.ts
200 · assinado403 · Forbidden200 · assinado200 · assinado// Your endpoint. The only place the app secret lives.app.post("/bird/auth", async (req, res) => { const { connection_id, channel_name } = req.body; const user = await session(req); if (!mayJoin(user, channel_name)) return res.sendStatus(403); // Signs <connection_id>:<channel_name>[:<member_data>] with the app // secret, and adds shared_secret on an encrypted channel. res.json( await bird.realtime.authorizeChannel({ connectionId: connection_id, channelName: channel_name, memberData: JSON.stringify({ member_id: user.id, member_info: { name: user.name }, }), }), );});
POST/bird/auth
Corpo da resposta
{ "auth": "d0e95a856ddc1b09d4c8:8f9a2c71e4…", "member_data": "{\"member_id\":\"u_42\",\"member_info\":{\"name\":\"Maya Chen\"}}" }
auth.ts
200 · assinado403 · Forbidden200 · assinado200 · assinado// Your endpoint. The only place the app secret lives.app.post("/bird/auth", async (req, res) => { const { connection_id, channel_name } = req.body; const user = await session(req); if (!mayJoin(user, channel_name)) return res.sendStatus(403); // Signs <connection_id>:<channel_name>[:<member_data>] with the app // secret, and adds shared_secret on an encrypted channel. res.json( await bird.realtime.authorizeChannel({ connectionId: connection_id, channelName: channel_name, memberData: JSON.stringify({ member_id: user.id, member_info: { name: user.name }, }), }), );});
POST/bird/auth
Corpo da resposta
{ "auth": "d0e95a856ddc1b09d4c8:8f9a2c71e4…", "member_data": "{\"member_id\":\"u_42\",\"member_info\":{\"name\":\"Maya Chen\"}}" }
Envie uma chave pública aos clientes
mantendo os segredos de assinatura no seu servidor.
Um app na API Realtime da Bird separa as credenciais de conexão do cliente da autoridade do backend. Navegadores e apps móveis abrem WebSockets com uma chave pública do app, segura para incluir nos bundles do cliente, enquanto seu backend guarda o segredo usado para publicar eventos e assinar tokens de inscrição. Quando sua política de segurança exigir rotação de credenciais, você pode criar um segundo par de chaves, implantá-lo nos seus serviços e revogar o par anterior sem derrubar usuários ativos.
Proteja conexões, canais e payloads em cada camada
Verifique quem pode abrir um socket, autorize em quais canais cada um entra, criptografe dados sensíveis de eventos e corte o acesso quando uma sessão termina.
- 01
Inscrições em canais assinadas.
Quando um cliente web ou móvel se inscreve em um canal privado ou de presença, seu backend verifica a sessão do usuário e assina um token HMAC-SHA256 vinculado ao ID dessa conexão e ao nome do canal. Vincular a assinatura ao ID do socket impede que um token seja reutilizado em outra conexão, e as assinaturas de presença também fixam a identidade do membro exibida na sala.
- 02
Conexões WebSocket autenticadas.
Como sua chave pública do app fica no código do cliente, qualquer visitante poderia tentar abrir um WebSocket ocioso. Ao ativar conexões autorizadas, cada novo socket precisa se autenticar pelo seu backend em até 30 segundos, fazendo login ou se inscrevendo em um canal privado. Sockets não verificados são fechados automaticamente e não contam para sua cota de conexões.
- 03
Payloads com criptografia de ponta a ponta.
Para atualizações regulamentadas ou confidenciais, o SDK de servidor criptografa os payloads dos eventos localmente com uma chave mestra de 32 bytes que permanece na sua infraestrutura. Cada canal criptografado deriva sua própria chave de descriptografia, então aprovar um cliente para um fluxo confidencial não concede acesso a outro, e os servidores intermediários veem apenas texto cifrado em trânsito.
- 04
Revogação instantânea de sessão.
Quando um usuário sai, troca a senha ou perde acesso ao espaço de trabalho, uma única chamada do servidor desconecta a identidade desse membro em todas as abas abertas e dispositivos móveis. Os clientes tratam o encerramento como definitivo em vez de reconectar em loop, e seu endpoint de autenticação pode rejeitar novas tentativas de login depois que a sessão é revogada.
Canais criptografados
Proteja payloads sensíveis antes que saiam do seu servidor.
Configure uma chave mestra de 32 bytes no SDK de servidor para criptografar eventos confidenciais dentro do seu próprio processo antes de publicá-los. A Bird encaminha o envelope selado aos assinantes, e seu endpoint de autorização entrega a chave de descriptografia derivada do canal aos clientes web aprovados. Você também pode combinar criptografia com cache do último evento para que clientes recém-conectados recebam o estado mais recente como texto cifrado. Como os metadados de roteamento não são criptografados, mantenha nomes de canais e eventos genéricos.
const bird = new BirdClient({
apiKey: process.env.BIRD_API_KEY!,
realtime: {
key: process.env.BIRD_REALTIME_KEY,
secret: process.env.BIRD_REALTIME_SECRET,
// 32 random bytes, yours alone. Never sent to Bird.
encryptionMasterKey: process.env.BIRD_REALTIME_MASTER_KEY,
},
});
// Sealed in your process. The edge forwards ciphertext.
await bird.realtime.publish(APP_ID, {
event: "order.updated",
channels: ["private-encrypted-orders"],
data: { order_id: "ord_123", status: "shipped" },
});
Isole fluxos por cliente e valide o estado no seu servidor.
Autenticação de conexão e autorização de canal resolvem partes diferentes do controle de acesso. Exigir conexões autorizadas bloqueia sockets anônimos, enquanto canais privados e de presença restringem qual usuário conectado ou cliente pode ler um fluxo específico. Mantenha atualizações específicas de clientes em canais privados verificados pelo seu endpoint de autenticação, use eventos entre clientes para sinais efêmeros de interface, como indicadores de digitação, e encaminhe ações que alteram estado pelo seu backend.
Fixe o tráfego em uma região e isole ambientes por app.
Escolha uma região dedicada ao criar um app Realtime para manter conexões WebSocket e eventos publicados perto dos seus usuários, mesmo que a região principal do seu espaço de trabalho seja outra. Como cada app roda em seu próprio namespace isolado, com credenciais e cotas separadas, criar apps distintos para desenvolvimento, homologação e produção mantém transmissões de teste fora dos canais de clientes reais.
Guias de implementação para seu backend.
Consulte autorização de canais para ver o formato da solicitação de webhook e os helpers de assinatura do SDK. Leia exigência de conexões autorizadas para aplicar o handshake de conexão de 30 segundos, canais criptografados para configurar chaves mestras e rotação de chaves, e encerramento de conexões de membros para implementar o login de usuários e a desconexão remota.
Continue criando
com o Realtime.
Combine autorização de canais com presença ao vivo, cache de estado e webhooks de backend usando as mesmas credenciais do app.
Canais
Encaminhe transmissões públicas, fluxos privados, payloads criptografados e estado em cache por prefixo de canal.
→Presença
Mostre quem está online em abas e dispositivos, acompanhe saídas e envie mensagens diretamente a usuários individuais.
→Webhooks
Acione fluxos no backend quando canais ficam ativos, membros saem ou um cache precisa ser preenchido.
→Escale sem perder o controle.
Separate production and sandbox traffic into dedicated workspaces, scope API keys to the exact channels each service or agent needs, and track permission changes in the audit log.