CS Fundamentals Trainer · Guias

Transações distribuídas: two-phase commit e sagas

Por que uma operação de negócio em vários bancos de dados é difícil, o two-phase commit (e como ele bloqueia), sagas com compensações e seu isolamento ausente, e passos idempotentes com um outbox, tudo executado no PostgreSQL e em pequenos serviços Python.

23 min de leitura

Fazer um pedido parece uma única ação, mas toca vários sistemas: o serviço de pedidos registra o pedido, o serviço de pagamentos cobra o dinheiro e o serviço de estoque reserva as mercadorias. Cada sistema tem o seu próprio banco de dados, e dentro de um banco uma transação dá o comportamento tudo-ou-nada de graça. Entre bancos, ninguém lhe dá isso, e as falhas são a parte interessante: o pagamento tem sucesso e a reserva de estoque falha, ou o servidor morre entre as duas. Este guia cobre o que fazer em vez de torcer: primeiro, evitar o problema; depois o two-phase commit (e por que ele bloqueia); depois as sagas, que trocam isolamento por disponibilidade; e os detalhes que fazem uma saga sobreviver a quedas. Executei o comportamento do banco de dados no PostgreSQL 16 e a saga em pequenos serviços Python, e o código está no apêndice. Cada resultado é uma execução em uma máquina pequena, então importam os comportamentos e não os tempos.

1. O problema: uma operação de negócio, vários donos

Uma transação em um único banco de dados tem quatro garantias (ACID): atomicidade (tudo ou nada), consistência (as restrições valem), isolamento (transações concorrentes não veem o trabalho pela metade umas das outras) e durabilidade (confirmado significa salvo). Veja os níveis de isolamento de transação para a terceira.

No momento em que dois bancos de dados separados, ou um banco de dados e uma API externa como um provedor de pagamentos, precisam mudar juntos, não existe um único lugar capaz de tornar o conjunto atômico. O código simples parece bom e falha nas brechas:

charge the card        // succeeds
reserve the stock      // fails: out of stock

Agora o cliente pagou por nada. Troque as duas linhas e uma queda depois da reserva deixa mercadorias seguradas para um pedido que nunca foi pago. Esse é o problema da escrita dupla (dual-write), e as opções abaixo diferem no que abrem mão.

2. Opção zero: não distribua a transação

A transação distribuída mais barata é a que você não tem. Antes de recorrer a um protocolo, pergunte se um único banco de dados pode ser dono da invariante.

Só quando a invariante realmente atravessa donos é que as duas ferramentas a seguir se aplicam.

3. Two-phase commit: tudo ou nada, com um preço

O two-phase commit (2PC) é o protocolo clássico para um commit atômico entre vários participantes (bancos de dados ou gerenciadores de recursos), executado por um coordenador (um gerenciador de transações).

Diagram: Two-phase commit

Na fase 1, cada participante faz o trabalho, o torna durável e vota. Um "sim" é uma promessa: a partir de agora o participante não pode mais decidir sozinho, precisa ser capaz de confirmar mesmo que caia e reinicie, e mantém seus locks até ouvir a decisão. Na fase 2, o coordenador, depois de registrar a decisão de forma durável, diz a todos para confirmar (se todos votaram sim) ou abortar (se algum votou não).

O PostgreSQL expõe o lado do participante como PREPARE TRANSACTION, COMMIT PREPARED e ROLLBACK PREPARED (precisa ser ativado com max_prepared_transactions, que é 0 por padrão). Isso é feito para gerenciadores de transações, não para código de aplicação. Executei uma transferência entre dois bancos de dados em um servidor PostgreSQL (um banco bank e um banco stock), eu mesmo fazendo o papel de coordenador:

CenárioO que aconteceu
Os dois fazem o prepare, depois os dois confirmamdepois do prepare as mudanças não eram visíveis (bank 100, stock 1); depois do COMMIT PREPARED, ambas eram (bank 70, stock 0)
Um participante não consegue fazer a sua partea atualização do estoque violou seu CHECK (qty >= 0) e falhou; o coordenador executou ROLLBACK PREPARED no banco, que ficou em 70: o resultado tudo-ou-nada
O coordenador morre depois de os dois terem feito o prepareas duas transações ficaram em pg_prepared_xacts; o UPDATE de outro cliente na mesma conta esperou e desistiu com um lock_timeout de 2 segundos; um SELECT simples ainda devolveu o valor antigo, porque os leitores não são bloqueados
O banco de dados reinicia enquanto há transações preparadasas duas transações preparadas ainda estavam lá depois da reinicialização; um coordenador em recuperação as concluiu com COMMIT PREPARED (bank 40, stock 4)

A terceira linha é a fraqueza do 2PC: ele é um protocolo bloqueante. Um participante que votou sim não pode confirmar nem abortar unilateralmente, porque não sabe o que os outros decidiram, então mantém seus locks até o coordenador voltar. Todo escritor que toca essas linhas fica na fila atrás dele. As transações preparadas também mantêm vivas versões antigas de linhas, o que impede a limpeza (vacuum) de recuperar espaço, então uma esquecida prejudica lentamente o banco de dados inteiro. Existem alternativas que evitam o ponto único de falha (commit baseado em consenso, three-phase commit), mas são raras em stacks de aplicação.

Custo. Cada participante grava em disco duas vezes (no prepare e no commit) em vez de uma, e o coordenador acrescenta o seu próprio log e idas e voltas de mensagens. Em um laço de 1 000 commits de uma linha em uma conexão, um commit simples levou de 0,27 a 0,32 s, e PREPARE TRANSACTION mais COMMIT PREPARED levaram de 0,46 a 0,51 s, cerca de 1,6 vez mais por participante. O disco daquele contêiner sincroniza rápido e não há rede, então, em hardware real com latência real, a diferença é maior, e quanto mais tempo os locks são mantidos, mais as outras transações esperam.

Quando o 2PC é um mau encaixe. Ele exige que todo participante o suporte, e muitos não suportam: a maioria dos brokers de mensagens, a API HTTP de um provedor de pagamentos, um serviço de terceiros e muitos bancos de dados gerenciados não podem participar. Ele acopla a disponibilidade de todos os participantes (um participante lento atrasa todos) e combina mal com trabalho de longa duração. Encaixa melhor dentro de uma organização, com poucos participantes que suportam XA (uma interface padrão para isso), transações curtas e um coordenador confiável. As sagas são a resposta usual fora desse caso.

4. Sagas: uma sequência de transações locais com passos de desfazer

Uma saga (Garcia-Molina e Salem, 1987) substitui uma grande transação distribuída por uma sequência de transações locais, cada uma confirmada por conta própria. Se um passo falha, a saga não faz rollback (os passos anteriores já foram confirmados e são visíveis); ela executa transações compensatórias que desfazem o efeito de negócio dos passos já feitos, em ordem inversa.

Diagram: A saga with a compensation

Há duas maneiras de coordenar os passos:

OrquestraçãoCoreografia
Comoum orquestrador central (uma máquina de estados) diz a cada serviço o que fazer em seguidacada serviço reage aos eventos publicados pelos outros
Onde o fluxo moraem um só lugar, fácil de ler, testar e monitorarespalhado entre os serviços, implícito
Acoplamentoos serviços dependem dos comandos do orquestradoros serviços dependem dos eventos uns dos outros, e o risco de ciclos cresce com cada novo evento
Encaixa emfluxos com muitos passos ou ramificaçõesdois ou três passos com regras simples

Prefira a orquestração quando um fluxo tem mais que alguns passos. Na coreografia, ninguém consegue responder "onde está o pedido 42 agora?" sem juntar os logs de cada serviço.

Compensação não é rollback

Um rollback faz a mudança nunca ter acontecido. Uma compensação é uma nova ação de negócio que desfaz o efeito de uma anterior, e o efeito anterior foi visível nesse meio-tempo. Consequências:

5. O que uma saga abre mão: o isolamento

Cada passo é confirmado imediatamente, então outras transações podem ver os estados intermediários: uma saga abre mão do isolamento, e o que ela oferece no lugar da atomicidade é mais fraco que o de uma transação: ou todos os passos se completam, ou executam-se compensações destinadas a trazer o negócio de volta a um estado válido. Se elas conseguem depende de as invariantes terem sido projetadas (o que é um estado válido, o que cada compensação restaura) e de que todas as compensações e caminhos de recuperação realmente tenham sucesso. Nenhum framework de sagas garante a consistência eventual por si só. O isolamento ausente é visível no teste. Um leitor amostrou o saldo da conta enquanto uma saga cobrava 30 e depois falhava no passo de estoque; ele viu 10 (depois da cobrança) e depois 40 de novo (depois do estorno) ao longo de cerca de um décimo de segundo. Por um instante o cliente teve menos dinheiro do que no início ou no fim. Outras anomalias decorrem disso: duas sagas que atualizam o mesmo registro podem se sobrescrever (uma lost update), e uma saga pode ler dados que outra saga está prestes a compensar.

As contramedidas padrão, da mais barata à mais pesada:

Quais anomalias importam depende do negócio. Um sistema de reservas não pode vender o mesmo assento duas vezes (use uma reserva); um dashboard que mostra brevemente um saldo menor pode não importar.

6. Fazendo cada passo sobreviver a quedas

O orquestrador é um programa, e os programas caem. Três hábitos transformam o esboço acima em algo que você pode executar.

  1. Persista o progresso da saga. Guarde o id da saga, o passo atual e seu estado (RUNNING, COMPENSATING, DONE, COMPENSATED) em um banco de dados, atualizado depois de cada passo. Depois de uma reinicialização, o orquestrador o lê e continua. Uma máquina de estados em memória se perde com o processo.
  2. Torne cada passo idempotente, com chave no id da saga. A pior queda é depois de o passo acontecer, mas antes de ser registrado. No teste, o orquestrador morreu logo depois de cobrar o cartão e antes de gravar "cobrança concluída". O log ainda dizia passo 1, então, na reinicialização, ele executou a cobrança de novo; o serviço de pagamentos tinha registrado charge:<saga id> na mesma transação da mudança de saldo, reconheceu a repetição e não fez nada. O saldo era 40 após a queda e 40 após a retomada, não 10. Para um provedor externo, passe uma chave de idempotência derivada, como em projetando uma API REST.
  3. Envie comandos de forma confiável. Se o orquestrador atualiza o log da saga e depois publica uma mensagem a um serviço, são duas escritas de novo. Grave o comando em um outbox na mesma transação do estado da saga e deixe um relay entregá-lo pelo menos uma vez (filas de mensagens e garantias de entrega); os receptores precisam tolerar duplicatas.

Os limites das chaves de idempotência

Uma chave de idempotência torna uma repetição inofensiva somente dentro do que o receptor promete. Para um serviço externo, como um provedor de pagamentos, confira três coisas:

A demonstração não é um orquestrador de produção

O exemplo em Python no apêndice existe para mostrar as ideias (progresso persistido, passos idempotentes, compensação, retry). Um workflow de produção precisa de mais:

Essa é a principal razão para usar um motor de workflow em vez de escrever o laço você mesmo.

Outras coisas de que uma saga de produção precisa: um timeout em cada passo (um serviço que nunca responde deve levar à compensação, não a uma espera eterna), uma forma de ver e consertar sagas travadas (um dashboard, um alerta, uma nova tentativa manual) e uma decisão sobre o que significa uma compensação que falhou (normalmente um humano cuida disso). Motores de workflow como o Temporal, o AWS Step Functions ou o Camunda guardam o estado, os retries e os timers para você, e é por isso que muitas equipes usam um em vez de construir esse laço por conta própria.

7. Escolhendo

SituaçãoRecorra a
Os dados podem morar em um banco de dadosuma transação local normal (opção zero)
Poucos gerenciadores de recursos, sob seu controle, todos com suporte a XA, operações curtastwo-phase commit
Vários serviços, APIs externas, passos de longa duração, a disponibilidade importauma saga (orquestrada, com passos idempotentes)
Um efeito colateral que só precisa acontecer eventualmente (recibo, atualização de índice)um outbox e um consumidor idempotente
O negócio não tolera nem breves estados intermediáriosredesenhe a fronteira, ou use reservas

Em uma entrevista, a resposta forte começa com "dá para evitar uma transação distribuída?" e nomeia o preço de cada opção: o 2PC bloqueia e exige o suporte de todos os participantes; as sagas são disponíveis, mas não isoladas e exigem um design de compensação.

8. Erros comuns

  1. Cobrar primeiro e chamar o serviço seguinte sem plano para a falha dele (sem compensação, sem estado).
  2. Tratar uma compensação como um rollback: supor que nada observou o estado intermediário, ou que o desfazer sempre funciona.
  3. Passos e compensações não idempotentes, de modo que uma nova tentativa depois de uma queda cobra ou estorna duas vezes.
  4. Manter o estado da saga apenas na memória.
  5. Atualizar o log da saga e enviar o comando seguinte como duas escritas separadas.
  6. Executar 2PC entre serviços ou provedores que não o suportam, ou deixar transações preparadas por aí depois de uma falha.
  7. Sem timeouts: um serviço travado segura uma saga (e os locks do 2PC) para sempre.
  8. Pôr passos irreversíveis no começo da saga.
  9. Distribuir uma transação por causa de como os serviços foram cortados, quando juntá-los eliminaria a necessidade.

9. Coisas a mencionar em uma entrevista

Perguntas que os entrevistadores gostam de acrescentar:

Resumo rápido

  1. Entre bancos de dados não existe atomicidade de graça: evite a transação distribuída se um dono ou a consistência eventual bastarem.
  2. 2PC: prepare (uma promessa durável, locks mantidos) e depois commit. No teste, as mudanças ficaram invisíveis até o COMMIT PREPARED, e um coordenador morto deixou as duas transações segurando seus locks, sobrevivendo até a uma reinicialização do banco de dados.
  3. O 2PC custa cerca de 1,6 vez o trabalho de disco por participante no teste e, mais importante, bloqueia escritores enquanto está em dúvida; muitos sistemas não conseguem participar.
  4. Uma saga é uma sequência de transações locais confirmadas com compensações; não tem isolamento, então os estados intermediários são visíveis (o saldo mostrou 10 e depois 40), e só restaura um estado válido se as invariantes e todos os caminhos de compensação tiverem sido projetados para isso.
  5. Compensação é uma nova ação de negócio, não um rollback: precisa ser repetível, e os passos irreversíveis vão por último.
  6. Persista o estado da saga, dê a cada passo uma chave com o id da saga e envie os comandos por um outbox; uma cobrança repetida depois de uma queda deixou o saldo inalterado.
  7. Ordene os passos como compensáveis, pivô, repetíveis; acrescente timeouts e um jeito de ver sagas travadas.

Apêndice: o código dos experimentos

Execute você mesmo. O primeiro precisa de um servidor PostgreSQL iniciado com max_prepared_transactions acima de 0 (por exemplo postgres -c max_prepared_transactions=20); o segundo precisa apenas do Python 3.

PostgreSQL: um two-phase commit à mão

Crie dois bancos de dados, bank (tabela accounts(id int primary key, balance int check (balance >= 0)), uma linha com saldo 100) e stock (tabela stock(item text primary key, qty int check (qty >= 0)), uma linha ('book', 1)). Depois, como coordenador, execute cada linha no banco de dados nomeado no comentário:

-- in database bank
BEGIN; UPDATE accounts SET balance = balance - 30 WHERE id = 1; PREPARE TRANSACTION 'o1-bank';
-- in database stock
BEGIN; UPDATE stock SET qty = qty - 1 WHERE item = 'book'; PREPARE TRANSACTION 'o1-stock';
-- both voted yes: look at them, and note that SELECT still shows the old values
SELECT gid, prepared FROM pg_prepared_xacts;
-- phase 2, in each database
COMMIT PREPARED 'o1-bank';      -- in bank
COMMIT PREPARED 'o1-stock';     -- in stock
-- to abort instead, when one side failed
ROLLBACK PREPARED 'o1-bank';

Para ver o bloqueio, faça o prepare nos dois e pare aí: então SET lock_timeout = '2s'; UPDATE accounts SET balance = balance - 1 WHERE id = 1; em outra sessão espera e falha. Reinicie o servidor e o pg_prepared_xacts ainda as lista.

Python: uma saga orquestrada com injeção de falhas

Salve como saga.py e execute python3 saga.py. Ele imprime os quatro cenários descritos acima. É um exemplo de ensino: tem um processo, um worker, retries em memória e nenhum versionamento, e omite tudo o que está listado em "A demonstração não é um orquestrador de produção".

import os, sqlite3, tempfile, threading, time

tmp = tempfile.mkdtemp()
def db(name):
    return sqlite3.connect(os.path.join(tmp, name), isolation_level=None, check_same_thread=False, timeout=5)
orders, pay, stock, log = db("orders"), db("payments"), db("stock"), db("saga_log")
orders.execute("create table orders(id text primary key, status text)")
pay.execute("create table accounts(id int primary key, balance int)")
pay.execute("create table done(step text primary key)")         # which (saga, step) already ran
pay.execute("insert into accounts values (1, 100)")
stock.execute("create table items(name text primary key, qty int)")
stock.execute("create table done(step text primary key)")
stock.execute("insert into items values ('book', 1)")
log.execute("create table saga(id text primary key, step int, state text)")   # durable progress

class Crash(Exception): pass
fail = {"stock": False, "refund_times": 0, "crash_after_charge": False}

# the local transactions of each service; each is idempotent per saga id
def create_order(sid):
    orders.execute("insert or ignore into orders values (?, 'PENDING')", (sid,))
def charge(sid, amount):
    pay.execute("begin")
    if pay.execute("select 1 from done where step=?", (f"charge:{sid}",)).fetchone():
        pay.execute("commit"); return                           # a repeat does nothing
    pay.execute("update accounts set balance = balance - ? where id=1", (amount,))
    pay.execute("insert into done values (?)", (f"charge:{sid}",))
    pay.execute("commit")
def refund(sid, amount):
    if fail["refund_times"] > 0:
        fail["refund_times"] -= 1; raise ConnectionError("payment service unavailable")
    pay.execute("begin")
    if pay.execute("select 1 from done where step=?", (f"refund:{sid}",)).fetchone():
        pay.execute("commit"); return
    pay.execute("update accounts set balance = balance + ? where id=1", (amount,))
    pay.execute("insert into done values (?)", (f"refund:{sid}",))
    pay.execute("commit")
def reserve(sid):
    if fail["stock"]: raise ValueError("out of stock")
    stock.execute("begin")
    if stock.execute("select 1 from done where step=?", (f"reserve:{sid}",)).fetchone():
        stock.execute("commit"); return
    n = stock.execute("update items set qty = qty - 1 where name='book' and qty > 0").rowcount
    if not n: stock.execute("rollback"); raise ValueError("out of stock")
    stock.execute("insert into done values (?)", (f"reserve:{sid}",)); stock.execute("commit")
def confirm(sid): orders.execute("update orders set status='CONFIRMED' where id=?", (sid,))
def cancel(sid): orders.execute("update orders set status='CANCELLED' where id=?", (sid,))

def retry(fn, *a):                                              # compensations must eventually succeed
    for attempt in range(1, 10):
        try: return fn(*a), attempt
        except ConnectionError: time.sleep(0.05)
    raise RuntimeError("giving up: needs a human")

def run_saga(sid, amount=30):
    row = log.execute("select step, state from saga where id=?", (sid,)).fetchone()
    if not row: log.execute("insert into saga values (?, 0, 'RUNNING')", (sid,)); row = (0, "RUNNING")
    step, state = row
    def mark(s, st="RUNNING"): log.execute("update saga set step=?, state=? where id=?", (s, st, sid))
    try:
        if step < 1: create_order(sid); mark(1)
        if step < 2:
            charge(sid, amount)
            if fail["crash_after_charge"]: fail["crash_after_charge"] = False; raise Crash()
            mark(2)
        if step < 3: reserve(sid); mark(3)
        confirm(sid); mark(4, "DONE")
    except ValueError as e:                                      # a step failed for a business reason
        mark(step, "COMPENSATING")
        _, tries = retry(refund, sid, amount)
        cancel(sid); mark(step, "COMPENSATED")
        print(f"   {sid}: {e}; refunded after {tries} attempt(s), order cancelled")

def snap():
    bal = pay.execute("select balance from accounts").fetchone()[0]
    qty = stock.execute("select qty from items").fetchone()[0]
    st = dict(orders.execute("select id, status from orders").fetchall())
    return f"balance={bal} stock={qty} orders={st}"

print("1. happy path"); run_saga("s1"); print("  ", snap())
print("2. stock runs out at step 3 -> compensate"); fail["stock"] = True
fail["refund_times"] = 2; run_saga("s2"); print("  ", snap()); fail["stock"] = False
print("3. the orchestrator crashes after charging but before recording it, then restarts")
stock.execute("update items set qty = 5"); fail["crash_after_charge"] = True
try: run_saga("s3")
except Crash: print("   crashed; money already taken:", snap())
run_saga("s3"); print("   resumed:", snap())
print("4. what a reader sees while a saga is in flight (balance sampled every 2 ms)")
seen = []
stop = threading.Event()
def reader():
    r = db("payments")
    while not stop.is_set():
        seen.append(r.execute("select balance from accounts").fetchone()[0]); time.sleep(0.002)
def slow_reserve(sid): time.sleep(0.1); raise ValueError("out of stock")
reserve = slow_reserve
t = threading.Thread(target=reader); t.start(); before = pay.execute("select balance from accounts").fetchone()[0]
run_saga("s4"); time.sleep(0.02); stop.set(); t.join()
print(f"   balance before {before}; values seen during the saga: {sorted(set(seen))}; after {pay.execute('select balance from accounts').fetchone()[0]}")

Fontes

  1. H. Garcia-Molina e K. Salem, Sagas, ACM SIGMOD 1987. A definição original de uma saga e de transações compensatórias.
  2. Documentação do PostgreSQL, PREPARE TRANSACTION, com COMMIT PREPARED e ROLLBACK PREPARED. O lado do participante do two-phase commit, seu locking e seus avisos de limpeza.
  3. Chris Richardson, Pattern: Saga. Orquestração e coreografia, e as contramedidas para o isolamento ausente.
  4. Pat Helland, Life beyond Distributed Transactions: an Apostate's Opinion, CIDR 2007. Por que os sistemas grandes evitam transações distribuídas e como entidades e mensagens as substituem.

Pratique este tema: System Design System Design › Distributed systems

Mais guias