Capítulo 45 de 59

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

  1. Emitir eventos de digitação ou movimento de mouse via postgres_changes: Fazer uma operação de UPDATE no 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.
  2. 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.
  3. 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.