Supabase Realtime: Postgres Changes, Broadcast e Presence
Supabase Realtime em Alta Escala: Postgres Changes vs Broadcast vs Presence
Criar interfaces colaborativas e reativas em tempo real — como quadros no estilo Notion/Figma, chats corporativos, dashboards operacionais ao vivo e notificações instantâneas — tornou-se o padrão esperado em produtos digitais modernos.
O Supabase Realtime oferece uma infraestrutura global distribuída em Elixir/Phoenix capaz de manter milhões de conexões WebSockets abertas com latência inferior a 15 milissegundos.
No entanto, o maior erro arquitetural cometido por equipes de desenvolvimento é tratar todas as funcionalidades em tempo real como se fossem a mesma coisa, utilizando Postgres Changes (leitura do log de transações do banco) para eventos efêmeros de alta frequência, o que rapidamente estrangula a CPU do PostgreSQL e gera custos desnecessários.
Neste guia arquitetural completo, você compreenderá as diferenças fundamentais entre Postgres Changes, Broadcast e Presence, aprendendo a selecionar a modalidade correta para escalar sua aplicação Next.js com máxima performance e custo de infraestrutura otimizado.
1. A Arquitetura do Supabase Realtime
Por baixo do capô, o Supabase Realtime não roda dentro do PostgreSQL. Ele opera como um cluster independente de nós Elixir/Erlang (BEAM), projetado especificamente para gerenciar concorrência massiva e roteamento de mensagens via WebSockets.
┌─────────────────────────────────────────────────────────────┐
│ NAVEGADORES / CLIENTES │
│ (Aplicações Next.js conectadas via WebSockets) │
└──────────────┬──────────────────────────────┬───────────────┘
│ │
▼ ▼
┌─────────────────────────────────────────────────────────────┐
│ CLUSTER SUPABASE REALTIME (ELIXIR/BEAM) │
│ - Gerencia milhões de conexões simultâneas │
│ - Roteia mensagens em memória com latência sub-10ms │
│ - Valida assinaturas de canais com JWT / RLS │
└──────────────┬──────────────────────────────┬───────────────┘
│ │
(Apenas quando necessário) (Custo ZERO de DB)
▼ ▼
┌──────────────────────────────┐ ┌───────────────────────────┐
│ POSTGRESQL WAL STREAM │ │ BROADCAST & PRESENCE │
│ - Lê mudanças persistidas │ │ - Mensagens em memória │
│ - Consome I/O e CPU do DB │ │ - CRDTs para estado │
└──────────────────────────────┘ └───────────────────────────┘
O cluster disponibiliza três primitivas arquiteturais distintas:
2. As Três Primitivas do Realtime
1. Postgres Changes (Sincronização de Banco via WAL)
O Postgres Changes escuta o Write-Ahead Log (WAL) do PostgreSQL através de replicação lógica. Toda vez que uma linha sofre INSERT, UPDATE ou DELETE, o banco notifica o Realtime, que aplica as políticas de Row Level Security (RLS) e despacha o dado para os clientes inscritos.
- Quando Usar: Status de pedidos e faturas, aprovação de cadastros, novos registros gravados no banco que precisam refletir na tela imediatamente.
- Impacto em Infraestrutura: Médio/Alto (consome I/O do disco e ciclos de CPU do banco para avaliar o WAL e o RLS a cada mutação).
// Exemplo: Escutando mudancas de status em pedidos
const channel = supabase
.channel("realtime-orders")
.on(
"postgres_changes",
{
event: "UPDATE",
schema: "public",
table: "orders",
filter: `organization_id=eq.${orgId}`,
},
(payload) => {
console.log("Pedido atualizado no banco:", payload.new);
}
)
.subscribe();
2. Broadcast (Mensagens Efêmeras de Custo Zero de Banco)
O Broadcast é uma rede pura de mensageria Publish/Subscribe em memória. As mensagens trafegam de um cliente para os demais clientes da sala sem jamais tocar no banco de dados PostgreSQL.
- Quando Usar: Indicadores de digitação em chats ("Fulano está digitando..."), cursores de mouse compartilhados, transmissões ao vivo, telemetria de sensores, eventos de jogos e notificações transitórias.
- Impacto em Infraestrutura: Praticamente nulo para o banco de dados (o tráfego ocorre 100% na malha em memória do cluster Realtime).
// Exemplo: Transmitindo a posicao do cursor do mouse em tempo real
const channel = supabase.channel(`room-${roomId}`, {
config: { broadcast: { self: false } },
});
// 1. Escuta cursores de outros usuarios conectados
channel.on("broadcast", { event: "cursor-pos" }, ({ payload }) => {
renderRemoteCursor(payload.userId, payload.x, payload.y);
});
channel.subscribe((status) => {
if (status === "SUBSCRIBED") {
// 2. Dispara a posicao local sem gravar nada no Postgres
channel.send({
type: "broadcast",
event: "cursor-pos",
payload: { userId: currentUserId, x: 120, y: 340 },
});
}
});
3. Presence (Estado de Usuários Conectados e Colaboração)
O Presence utiliza CRDTs (Conflict-Free Replicated Data Types) para sincronizar automaticamente a lista de usuários ativos em uma sala, lidando de forma transparente com quedas de conexão de rede e reconexões.
- Quando Usar: Avatares de usuários visualizando o mesmo documento, contadores de audiência em tempo real, status online/offline de atendentes e salas de videoconferência.
- Impacto em Infraestrutura: Custo zero de banco de dados (sincronização descentralizada em memória).
// Exemplo: Sincronizando presenca de colaboradores em um documento
const channel = supabase.channel(`document-${docId}`);
channel
.on("presence", { event: "sync" }, () => {
const state = channel.presenceState();
console.log("Usuarios atualmente online no documento:", state);
})
.on("presence", { event: "join" }, ({ key, newPresences }) => {
console.log("Novo colaborador entrou:", newPresences);
})
.on("presence", { event: "leave" }, ({ key, leftPresences }) => {
console.log("Colaborador saiu:", leftPresences);
})
.subscribe(async (status) => {
if (status === "SUBSCRIBED") {
// Registra a presenca do usuario logado com metadados
await channel.track({
userId: user.id,
userName: user.fullName,
avatarUrl: user.avatarUrl,
onlineAt: new Date().toISOString(),
});
}
});
3. Matriz Comparativa das Modalidades
| Critério Arquitetural | Postgres Changes | Broadcast | Presence |
|---|---|---|---|
| Persistência no Banco | Sim (Gravado no PostgreSQL) | Não (Volátil / Em Memória) | Não (Volátil / Em Memória) |
| Latência Média | 50ms – 150ms (Gravação + WAL) | Sub-15ms (Ponto a Ponto) | Sub-20ms (Sincronização CRDT) |
| Custo de I/O no Banco | Sim (Escrita e leitura de WAL) | Zero (Não toca no DB) | Zero (Não toca no DB) |
| Resolução de Conflitos | Transacional ACID do Postgres | N/A (Disparo efêmero) | CRDTs Nativos |
| Filtragem por Linha | Via RLS e filtros SQL | Via Canais e Tags | Via Salas e Canais |
| Ideal para | CRUD de Negócio e Faturamento | Chats, Cursores e Telemetria | Usuários Online e Colaboração |
4. Segurança e Canais Privados com RLS
No Supabase Realtime, você pode configurar Canais Privados onde o cliente deve apresentar um JWT assinado válido para ingressar na sala.
Autorização de Canais no PostgreSQL:
Você pode definir políticas no PostgreSQL na tabela realtime.messages para controlar quem pode emitir ou escutar broadcasts:
-- 1. Habilita RLS no esquema de mensagens do Realtime
ALTER TABLE realtime.messages ENABLE ROW LEVEL SECURITY;
-- 2. Permite que usuarios escutem apenas mensagens de sua propria organizacao
CREATE POLICY "Users can only listen to their organization broadcast"
ON realtime.messages
FOR SELECT
TO authenticated
USING (
EXISTS (
SELECT 1 FROM organization_members
WHERE organization_members.org_id = (realtime.topic())::uuid
AND organization_members.user_id = auth.uid()
)
);
5. Padrão Ouro de Implementação no React / Next.js
Para evitar vazamentos de memória (memory leaks) causados pelo acúmulo de sockets abertos ao navegar entre páginas, implemento um Custom Hook com Cleanup rigoroso:
// src/hooks/useRealtimeRoom.ts
"use client";
import { useEffect, useState } from "react";
import { createBrowserClient } from "@/lib/supabase/client";
import { RealtimeChannel } from "@supabase/supabase-js";
interface UseRealtimeRoomOptions {
roomId: string;
onBroadcast?: (event: string, payload: unknown) => void;
onPresenceSync?: (presenceState: Record<string, unknown[]>) => void;
}
export function useRealtimeRoom({
roomId,
onBroadcast,
onPresenceSync,
}: UseRealtimeRoomOptions) {
const [channel, setChannel] = useState<RealtimeChannel | null>(null);
const [isConnected, setIsConnected] = useState(false);
const supabase = createBrowserClient();
useEffect(() => {
// 1. Cria a instancia do canal para a sala especifica
const roomChannel = supabase.channel(`room:${roomId}`, {
config: {
broadcast: { self: false },
presence: { key: roomId },
},
});
if (onBroadcast) {
roomChannel.on("broadcast", { event: "*" }, ({ event, payload }) => {
onBroadcast(event, payload);
});
}
if (onPresenceSync) {
roomChannel.on("presence", { event: "sync" }, () => {
onPresenceSync(roomChannel.presenceState());
});
}
roomChannel.subscribe((status) => {
setIsConnected(status === "SUBSCRIBED");
});
setChannel(roomChannel);
// 2. CLEANUP OBRIGATORIO: Destroi o canal ao desmontar o componente
return () => {
supabase.removeChannel(roomChannel);
};
}, [roomId]);
return { channel, isConnected };
}
6. Anti-Patterns Críticos em Arquiteturas Realtime
- Emitir eventos de digitação ou movimento de mouse via
postgres_changes: Fazer uma operação deUPDATEno PostgreSQL toda vez que o usuário move o mouse ou digita uma letra gerará milhares de transações por segundo no banco, esgotando conexões do pooler e travando a base. Use sempre Broadcast para dados efêmeros. - Esquecer a Função de Limpeza (
removeChannel): Se o usuário navegar por 10 páginas que abrem canais sem destruí-los, o navegador manterá 10 conexões ativas, duplicando o processamento e estourando o limite de conexões simultâneas da conta. - Não Filtrar Mudanças de Tabela: Escutar uma tabela inteira sem especificar um filtro (
filter: 'org_id=eq.X') força o cliente a receber todas as mutações da base de dados, gerando consumo massivo de banda e vulnerabilidades de segurança.
Conclusão: Escalabilidade Realtime com Precisão de Engenharia
O ecossistema Supabase Realtime elimina a necessidade de configurar e manter clusters complexos de Redis, Socket.io ou servidores dedicados de WebSockets.
Ao separar com clareza o que exige persistência em banco (Postgres Changes) do que é tráfego efêmero de alta velocidade (Broadcast e Presence), sua aplicação entrega uma experiência interativa de altíssimo nível, com latência imperceptível e custos de infraestrutura rigorosamente controlados.
Se a sua empresa precisa projetar plataformas colaborativas em tempo real, dashboards operacionais ou arquiteturas de alta concorrência com Next.js e Supabase, conheça minhas soluções de desenvolvimento corporativo ou agende uma análise técnica comigo.