A maioria dos times encontra seu primeiro obstáculo de escalonamento no Elixir não porque a BEAM não aguenta a carga — ela aguenta — mas porque trazem intuições do modelo de threads para um mundo baseado em atores. Procuram connection pools onde deveriam lançar processos, adicionam mutexes onde deveriam estar árvores de supervisão, e escalam horizontalmente antes de entender o que acontece dentro de um único nó.
Este é um guia de campo sobre o que realmente funcionou quando levamos uma plataforma de pagamentos em tempo real de 40.000 requisições por segundo para mais de um milhão, em um cluster de 12 nós, com latência P99 abaixo de 10ms e zero tempo de inatividade planejado durante o escalonamento.
Por Que a BEAM Muda as Regras
Antes de entrar na arquitetura, vale entender por que o Elixir é diferente em nível fundamental — não porque a documentação diz isso, mas porque muda cada decisão que você toma.
Runtimes tradicionais (JVM, Node, Go) modelam concorrência sobre primitivos do sistema operacional. Uma goroutine ainda é agendada pelo runtime do Go e mapeada para threads do SO. Uma virtual thread da JVM ainda aloca uma stack. Essas abstrações reduzem o custo, mas o modelo subjacente permanece: memória compartilhada, locks, e o risco constante de uma operação lenta bloquear as demais.
A BEAM é diferente. Cada processo é uma unidade completamente isolada com seu próprio heap, seu próprio garbage collector e sua própria fila de mensagens. Quando um processo trava, ele trava sozinho. Quando o GC executa, ele opera sobre o heap de um processo sem parar o mundo. Na inicialização, um processo BEAM custa aproximadamente 2–3 KB — portanto lançar 100.000 deles não é uma crise de recursos, é operação normal.
Isso não é teórico. Com 1M RPS sustentados, tínhamos aproximadamente 800.000 processos ativos no pico. Em uma stack JVM, esse número seria absurdo. Na BEAM, era uma terça-feira qualquer.
Modelando o Domínio como Atores
A primeira mudança arquitetural é conceitual: pare de pensar em termos de request handlers e comece a pensar em entidades de domínio com seu próprio ciclo de vida.
Em nossa plataforma de pagamentos, cada conta tem seu próprio processo com estado. Rotear uma transação significa encontrar ou lançar o processo daquela conta e enviar uma mensagem para ele. O processo da conta serializa operações naturalmente — não é necessário locking a nível de banco de dados para verificar saldos, porque o processo é o limite de serialização.
defmodule Payments.AccountProcess do
use GenServer
def start_link(account_id) do
GenServer.start_link(__MODULE__, account_id,
name: {:via, Registry, {Payments.Registry, account_id}}
)
end
def init(account_id) do
state = Payments.Store.load_account(account_id)
{:ok, state}
end
def handle_call({:authorize, txn}, _from, state) do
case authorize_transaction(txn, state) do
{:ok, new_state} ->
{:reply, {:ok, txn.id}, new_state}
{:error, reason} ->
{:reply, {:error, reason}, state}
end
end
defp authorize_transaction(%{amount: amount}, %{balance: balance})
when amount > balance,
do: {:error, :insufficient_funds}
defp authorize_transaction(txn, state) do
new_state = %{state |
balance: state.balance - txn.amount,
pending: [txn.id | state.pending]
}
{:ok, new_state}
end
end
A linha-chave é {:via, Registry, {Payments.Registry, account_id}}. Isso registra o processo sob o ID da conta em um registry local, para que qualquer chamador possa rotear para ele sem conhecer o PID. A busca no registry é uma operação O(1) sobre ETS — rápida o suficiente para fazer em cada requisição.
Construindo Árvores de Supervisão Confiáveis
A segunda mudança é operacional: sua árvore de supervisão é seu contrato de confiabilidade. Não é uma curiosidade que você configura uma vez e esquece.
A 1M RPS, haverá falhas de processo. Uma transação malformada, um timeout de rede para um serviço dependente, um nil inesperado — processos vão morrer. A questão não é se falhas acontecem, mas se você projetou a semântica de reinício corretamente.
Estruturamos a supervisão em três camadas:
defmodule Payments.Application do
use Application
def start(_type, _args) do
children = [
# Infraestrutura — inicia primeiro, uma falha não reinicia irmãos
{Registry, keys: :unique, name: Payments.Registry},
Payments.Store,
Payments.EventBus,
# Processos de conta — isolados, reiniciam individualmente
{DynamicSupervisor,
name: Payments.AccountSupervisor,
strategy: :one_for_one,
max_restarts: 10,
max_seconds: 1},
# Pipeline de ingestão — se morrer, reinicia tudo em ordem
{Supervisor,
children: [Payments.Router, Payments.RateLimiter],
strategy: :rest_for_one}
]
Supervisor.start_link(children, strategy: :one_for_one)
end
end
:one_for_one no nível raiz significa que falhas de infraestrutura ficam isoladas. :rest_for_one no pipeline de ingestão significa que se o Router travar, o RateLimiter (que depende dele) também reinicia — em ordem. Essas não são escolhas arbitrárias; elas codificam o grafo de dependências do sistema.
Uma lição aprendida da maneira difícil: configure max_restarts e max_seconds de forma deliberada. O padrão permite 3 reinícios em 5 segundos. Em um cenário de thundering herd, um processo vinculado a um serviço externo com problemas pode esgotar esse orçamento instantaneamente, escalar para seu supervisor e propagar a falha para cima. Ajustamos para 10 reinícios por segundo nos nós folha e adicionamos circuit breakers no limite.
Clustering Horizontal com libcluster
Um único nó BEAM lidava com cerca de 90k RPS em nossos benchmarks. Para chegar a 1M, precisávamos de 12 nós com distribuição correta. A distribuição integrada do Elixir torna isso surpreendentemente simples usando libcluster.
# config/releases.exs
config :libcluster,
topologies: [
payments: [
strategy: Cluster.Strategy.Kubernetes.DNS,
config: [
service: "payments-headless",
application_name: "payments",
polling_interval: 5_000
]
]
]
Com os nós conectados, :pg (Process Groups) oferece descoberta de processos a nível de cluster sem um coordenador central:
defmodule Payments.Router do
def route(txn) do
node = least_loaded_node(txn.account_id)
:erpc.call(node, Payments.AccountProcess, :authorize, [txn])
end
defp least_loaded_node(account_id) do
# Consistent hashing mantém a mesma conta no mesmo nó
# a menos que esse nó esteja indisponível — evita split-brain nos saldos
nodes = [Node.self() | Node.list()]
Enum.at(nodes, :erlang.phash2(account_id, length(nodes)))
end
end
O consistent hashing aqui é crítico. Se a conta abc123 sempre é roteada para o node-3, o AccountProcess desse nó tem o estado em memória quente. Com round-robin, cada requisição iniciaria a frio a partir do banco de dados. A 1M RPS, essa diferença é a margem entre um sistema funcionando e uma queda do banco de dados.
Backpressure com Broadway
Aceitar 1M RPS é um problema. Processá-los de forma confiável sem sobrecarregar sistemas dependentes é outro. É aqui que o Broadway — a biblioteca de processamento de dados orientada a demanda do Elixir — justifica sua presença.
defmodule Payments.IngestPipeline do
use Broadway
def start_link(_opts) do
Broadway.start_link(__MODULE__,
name: __MODULE__,
producer: [
module: {BroadwayKafka.Producer, [
hosts: [kafka: 9092],
group_id: "payments-ingest",
topics: ["raw-transactions"]
]},
concurrency: 4
],
processors: [
default: [concurrency: 50]
],
batchers: [
authorized: [concurrency: 10, batch_size: 500, batch_timeout: 50],
rejected: [concurrency: 4, batch_size: 200, batch_timeout: 100]
]
)
end
def handle_message(_, %Broadway.Message{data: txn} = msg, _) do
case Payments.Router.route(txn) do
{:ok, _} -> Broadway.Message.put_batcher(msg, :authorized)
{:error, _} -> Broadway.Message.put_batcher(msg, :rejected)
end
end
def handle_batch(:authorized, messages, _, _) do
ids = Enum.map(messages, & &1.data.id)
Payments.Store.bulk_confirm(ids)
messages
end
end
O modelo orientado a demanda do Broadway significa que os produtores só emitem mensagens tão rápido quanto os processadores conseguem consumir. Não há um buffer ilimitado enchendo durante um pico de tráfego — o backpressure se propaga para o Kafka, que por sua vez aplica a pressão nos produtores de origem. O sistema se autorregula.
Os batchers são particularmente valiosos para escritas no banco de dados. Em vez de 500 chamadas INSERT individuais, agrupamos em operações bulk a cada 50ms. Com nosso throughput, isso reduziu a carga de escrita no banco de dados em aproximadamente 80%.
Os Números Reais
Após implantação completa em 12 nós:
- Throughput sustentado: 1,2M RPS
- Latência P50: 2ms
- Latência P99: 8ms
- Latência P99.9: 31ms
- Processos ativos no pico: ~800.000
- Memória por nó: 4,2 GB em média (32 GB disponíveis)
- Estratégia de implantação: reinícios progressivos, zero queda de tráfego
O número dos reinícios progressivos é o que mais nos orgulha. Como cada nó mantém a propriedade por consistent hashing de seus processos de conta, conseguimos drenar um nó, reiniciá-lo com novo código e reconectá-lo — enquanto o tráfego migrava para os 11 nós restantes — sem perder uma única transação. O hot code loading da BEAM tornou isso possível; o design da árvore de supervisão tornou isso seguro.
Lições que Vale Guardar
Modele domínios como processos, não como registros. Se uma entidade tem estado que muda ao longo do tempo, provavelmente deveria ser um processo. A serialização que você implementaria de outra forma em SQL ou Redis vem de graça.
Árvores de supervisão codificam seu modelo de falhas. Antes de escrever um único use GenServer, desenhe o grafo de dependências e decida quais reinícios se propagam e quais não. A estratégia errada a 40k RPS é um bug. A 1M RPS, é uma queda.
Consistent hashing supera round-robin em escala. Localidade importa. Estado de processo quente é gratuito. Cache misses a um milhão de requisições por segundo não são.
Broadway para qualquer pipeline com I/O. Se você consome do Kafka, SQS ou qualquer fonte externa e escreve em um banco de dados, o modelo orientado a demanda do Broadway vai te salvar de reinventar o backpressure da forma errada.
Meça antes de escalar horizontalmente. Passamos duas semanas otimizando um único nó antes de adicionar o segundo. Cada gargalo que encontramos lá — uma chamada bloqueante ao banco de dados em um caminho de inicialização, uma configuração errada da árvore de supervisão, um pico de contenção no Registry — teria se multiplicado pelo cluster.
A BEAM foi construída para isso. A questão é se sua arquitetura também está.
Marcado em