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.
- Ponha os dados que precisam mudar juntos em um banco de dados. Se "um pedido e sua reserva de estoque" precisam ser atômicos, provavelmente pertencem a um serviço e a um schema. Dividir os serviços pela linha errada é o motivo usual de precisar deste guia.
- Mantenha a invariante de um lado. Reserve o estoque primeiro (uma transação local), depois peça o pagamento e trate "pagamento falhou" como um evento de negócio que libera a reserva, em vez de tentar confirmar os dois de uma vez.
- Aceite a consistência eventual onde o negócio aceita. Enviar um recibo, atualizar um índice de busca ou um dashboard não precisa ser confirmado junto com o pedido. Grave um evento no mesmo banco de dados na mesma transação (o outbox, veja filas de mensagens e garantias de entrega) e deixe-o se propagar.
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ário | O que aconteceu |
|---|---|
| Os dois fazem o prepare, depois os dois confirmam | depois 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 parte | a 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 prepare | as 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 preparadas | as 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ção | Coreografia | |
|---|---|---|
| Como | um orquestrador central (uma máquina de estados) diz a cada serviço o que fazer em seguida | cada serviço reage aos eventos publicados pelos outros |
| Onde o fluxo mora | em um só lugar, fácil de ler, testar e monitorar | espalhado entre os serviços, implícito |
| Acoplamento | os serviços dependem dos comandos do orquestrador | os serviços dependem dos eventos uns dos outros, e o risco de ciclos cresce com cada novo evento |
| Encaixa em | fluxos com muitos passos ou ramificações | dois 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:
- Algumas coisas não podem ser desfeitas: um e-mail já enviado, uma encomenda já despachada, dinheiro já pago. Uma compensação pode ser um pedido de desculpas, uma etiqueta de devolução ou um crédito. Ponha esses passos por último, depois dos passos que ainda podem falhar.
- As compensações precisam ser repetíveis (idempotentes) e precisam eventualmente ter sucesso, porque não há nada a que recorrer se o desfazer falhar. No teste, o estorno falhou duas vezes (o serviço de pagamentos estava indisponível) e teve sucesso na terceira tentativa; a saga simplesmente continuou tentando.
- Os passos se dividem em três tipos. Os passos compensáveis vêm primeiro e podem ser desfeitos. O pivô é o passo depois do qual a saga vai se completar: uma vez confirmado, nenhuma compensação é executada. Os passos repetíveis (retriable) vêm depois dele e precisam continuar sendo repetidos até terem sucesso. Projete a ordem dos passos em torno disso: faça as coisas arriscadas e desfazíveis antes do pivô.
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:
- Lock semântico: um status que marca um registro como estando no meio de uma saga (
PENDING), que outras operações verificam e se recusam a tocar (ou esperam). O pedido ficouPENDINGaté o último passo no teste, então um leitor conseguia saber que ainda não era final. - Atualizações comutativas: projete as operações de modo que a ordem não importe (
balance + 30ebalance - 30podem ser aplicados em qualquer ordem), o que torna uma compensação segura mesmo depois de outras mudanças. - Reservas (try, confirm, cancel): o primeiro passo não toma o recurso, ele o reserva (segura 30 no cartão, segura um livro) e um passo posterior confirma ou libera a reserva. Os outros veem o recurso como indisponível e não como tomado e depois devolvido.
- Reler antes de escrever: confira se um valor está inalterado antes de sobrescrevê-lo, com um número de versão (a mesma ideia do
If-Matchem projetando uma API REST).
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.
- 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. - 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. - 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:
- Escopo. Uma chave normalmente está ligada a uma conta e a um endpoint, e muitos provedores rejeitam a mesma chave com parâmetros diferentes. Derive as chaves do id da saga e do passo (
order-<id>-charge) e nunca as reutilize entre operações. - Retenção. Os provedores lembram as chaves por um tempo limitado (muitas vezes cerca de um dia, veja a documentação deles). Uma nova tentativa depois de a chave expirar é uma nova requisição e pode cobrar duas vezes. Uma saga que pode esperar mais que o período de retenção (uma fila de retries depois de uma queda, uma nova tentativa manual) não deve depender apenas da chave.
- Resultados ambíguos. Um timeout não diz se a cobrança aconteceu. O estado honesto é desconhecido, não falhou. Registre-o como um estado próprio (
CHARGE_UNKNOWN) e depois resolva-o perguntando ao provedor (consulte o pagamento pela sua própria referência ou espere pelo webhook dele) antes de compensar ou tentar de novo. Execute um job de reconciliação que compare os seus registros com os relatórios do provedor e trate qualquer diferença (uma cobrança para a qual você não tem pedido, um pedido sem cobrança) como um caso para reparo. A idempotência evita a maioria das duplicatas; a reconciliação acha o resto.
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:
- Controle de concorrência. Dois workers nunca podem executar a mesma saga ao mesmo tempo: um lease ou uma coluna de versão conferida em toda atualização, para que um worker travado que acorde não possa sobrescrever o trabalho de quem assumiu.
- Retries e timers duráveis. O exemplo repete em um laço na memória. Um real guarda o horário da próxima tentativa, faz backoff com jitter, sobrevive a reinicializações e impõe o timeout em cada passo.
- Observabilidade. Um id de saga em cada linha de log e span de trace, métricas de sagas por estado e idade e um alerta para sagas que param de progredir (veja observabilidade).
- Estado de workflow versionado. As sagas podem rodar por horas ou dias, então o código que as retoma pode ser mais novo que o código que as iniciou. O estado armazenado e as definições dos passos precisam de versões, e um deploy não pode deixar encalhadas sagas que estão na metade.
- Compensações que falham permanentemente. Decida de antemão o que acontece quando um desfazer nunca pode ter sucesso: um estado dead-letter, um alerta, uma ferramenta de reparo manual e uma trilha de auditoria.
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ção | Recorra a |
|---|---|
| Os dados podem morar em um banco de dados | uma transação local normal (opção zero) |
| Poucos gerenciadores de recursos, sob seu controle, todos com suporte a XA, operações curtas | two-phase commit |
| Vários serviços, APIs externas, passos de longa duração, a disponibilidade importa | uma 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ários | redesenhe 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
- Cobrar primeiro e chamar o serviço seguinte sem plano para a falha dele (sem compensação, sem estado).
- Tratar uma compensação como um rollback: supor que nada observou o estado intermediário, ou que o desfazer sempre funciona.
- Passos e compensações não idempotentes, de modo que uma nova tentativa depois de uma queda cobra ou estorna duas vezes.
- Manter o estado da saga apenas na memória.
- Atualizar o log da saga e enviar o comando seguinte como duas escritas separadas.
- Executar 2PC entre serviços ou provedores que não o suportam, ou deixar transações preparadas por aí depois de uma falha.
- Sem timeouts: um serviço travado segura uma saga (e os locks do 2PC) para sempre.
- Pôr passos irreversíveis no começo da saga.
- 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
- Pergunte primeiro se a transação pode ser evitada (um só dono, ou consistência eventual).
- Explique o 2PC: prepare e depois commit, a promessa que um voto "sim" faz, por que ele bloqueia quando o coordenador falha e que muitos sistemas não conseguem participar.
- Explique uma saga: transações locais mais compensações, orquestração versus coreografia, nenhum isolamento e as contramedidas (lock semântico, reserva).
- Explique como ela sobrevive a quedas: estado persistido, passos idempotentes com chave no id da saga, outbox para os comandos, timeouts.
- Nomeie a ordem dos passos: compensáveis primeiro, pivô, repetíveis por último.
Perguntas que os entrevistadores gostam de acrescentar:
- "Por que não usar 2PC em todo lugar?" Ele bloqueia enquanto o coordenador está fora do ar, amarra a disponibilidade de todos os participantes e serviços externos não o suportam.
- "E se a compensação falhar?" Repita-a (precisa ser idempotente); se continuar falhando, a saga está travada e precisa de um alerta e de um humano ou de outro remédio de negócio.
- "Como você impede que duas sagas interfiram?" Locks semânticos, reservas, atualizações comutativas ou verificações de versão, escolhidos para a anomalia que importa.
- "Um serviço caiu depois de fazer o trabalho, mas antes de responder. O que acontece?" O orquestrador repete o passo; uma chave de idempotência torna a repetição inofensiva.
- "Uma saga é eventualmente consistente?" Só se for projetada para isso: o sistema chega a um estado válido quando a saga se completa ou todas as suas compensações têm sucesso, e fica visivelmente inconsistente no meio. Uma compensação que falha de vez, ou uma invariante para a qual ninguém escreveu uma compensação, deixa os dados errados até alguém reparar.
Resumo rápido
- 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.
- 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. - 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.
- 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.
- 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.
- 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.
- 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
- H. Garcia-Molina e K. Salem, Sagas, ACM SIGMOD 1987. A definição original de uma saga e de transações compensatórias.
- 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.
- Chris Richardson, Pattern: Saga. Orquestração e coreografia, e as contramedidas para o isolamento ausente.
- 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