Sagas: transações entre serviços
Troque transações distribuídas por sagas - uma sequência de transações locais com compensações - orquestradas ou coreografadas.
- Explicar por que uma única transação ACID não consegue abranger vários serviços, e por que o two-phase commit é pouco usado
- Projetar uma saga com ações de compensação e ordenar as etapas em torno do ponto sem volta
- Comparar orquestração e coreografia
Fazer um pedido na Galactic Noodle Express envolve quatro serviços: Pedidos o registra, Pagamentos cobra o cartão, a Cozinha reserva os ingredientes e cozinha, e Entrega lança um foguete. No monólito, uma única transação de banco de dados tornava tudo isso tudo-ou-nada. Com um banco de dados por serviço, não existe uma transação que abranja todos.
O two-phase commit (2PC) consegue coordenar uma transação distribuída, mas cada participante precisa segurar locks enquanto espera o coordenador, um serviço lento trava todo mundo, e a maioria dos brokers e dos bancos de dados modernos não o suporta entre serviços. Por isso os microsserviços usam uma saga:
- uma sequência de transações locais, uma por serviço, cada uma confirmada na hora;
- para cada etapa que talvez precise ser desfeita, uma transação de compensação que a reverte no sentido de negócio (estornar o cartão, liberar os ingredientes, cancelar o pedido);
- se uma etapa falhar, rode as compensações das etapas concluídas na ordem inversa.
Experimente
Até 15 XPSimulador de saga
Esta é a saga do pedido. Escolha uma etapa para falhar e leia o log.
- Faça Pagamentos falhar: o que é desfeito?
- Faça Entrega falhar, no final: por que a saga fica travada? Não dá para descozinhar o lámen.
- Repare na ordem das etapas. Onde as etapas irreversíveis devem ficar?
Escolha qual passo falha:
- 1. Pedidoscriar o pedido (pendente)desfazer: cancelar o pedido
- 2. Pagamentoscobrar o cartãodesfazer: estornar o cartão
- 3. Cozinhareservar os ingredientesdesfazer: liberar os ingredientes
- 4. Cozinhacozinhar o lámennão pode ser desfeito
- 5. Entregalançar o foguetenão pode ser desfeito
Log da saga
- ✓Pedidos: criar o pedido (pendente)
- ✓Pagamentos: cobrar o cartão
- ✓Cozinha: reservar os ingredientes
- ✓Cozinha: cozinhar o lámen
- ✓Entrega: lançar o foguete
Saga concluída: todos os serviços confirmaram seu passo.
As compensações são semânticas, não um desfazer mágico: um estorno não apaga a cobrança, ele acrescenta um lançamento que a reverte - e o cliente pode ver os dois por um tempo. Algumas etapas não podem ser desfeitas de jeito nenhum (cozinhar, enviar um e-mail, lançar um foguete). Estruture a saga em torno de um pivot:
- Primeiro as etapas compensáveis - o que pode ser desfeito.
- O pivot - o ponto sem volta.
- Depois dele, as etapas repetíveis - etapas que com certeza vão dar certo em algum momento se você continuar tentando (de forma idempotente), então nunca precisam de compensação.
No simulador, cozinhar é o pivot - e por isso lançar o foguete precisa ser tentado de novo até dar certo (com outro foguete, se for preciso), e não compensado.
Orquestração ou coreografia?
| Orquestração | Coreografia | |
|---|---|---|
| Quem decide a próxima etapa | um orquestrador central envia comandos (ChargeCard) e espera as respostas | cada serviço reage aos eventos do serviço anterior (OrderCreated → Pagamentos cobra) |
| Onde o fluxo fica visível | num só lugar - a máquina de estados do orquestrador | espalhado pelos serviços; você o reconstrói a partir dos eventos |
| Acoplamento | os serviços dependem dos comandos do orquestrador | os serviços dependem só dos eventos |
| Bom para | fluxos complexos, com muitas etapas e ramificações | fluxos simples, com poucos participantes |
Motores de workflow como Temporal, AWS Step Functions e Camunda são orquestradores duráveis: eles persistem o estado da saga, então ela sobrevive a quedas e continua de onde parou.
1steps = [("Orders", "create order", "cancel order"),
2 ("Payments", "charge card", "refund card"),
3 ("Kitchen", "reserve ingredients", "release ingredients")]
4
5def run(fail_at):
6 done = []
7 for index, (service, action, undo) in enumerate(steps):
8 if index == fail_at:
9 print(f" {service}: {action} FAILED - compensating")
10 for done_service, done_undo in reversed(done):
11 print(f" {done_service}: {done_undo}")
12 return "rolled back"
13 print(f" {service}: {action}")
14 done.append((service, undo))
15 return "completed"
16
17print("happy path:", run(None))
18print("kitchen out of noodles:", run(2))Orders: create order Payments: charge card Kitchen: reserve ingredients happy path: completed Orders: create order Payments: charge card Kitchen: reserve ingredients FAILED - compensating Payments: refund card Orders: cancel order kitchen out of noodles: rolled back
Principais conclusões
Uma saga é uma sequência de transações locais com transações de compensação, em vez de uma única transação distribuída.
Em caso de falha, compense as etapas concluídas na ordem inversa; as compensações são reversões semânticas, não apagamentos.
Coloque primeiro as etapas compensáveis, depois o pivot e por fim as etapas repetíveis que não podem falhar de vez.
A orquestração centraliza o fluxo; a coreografia deixa os serviços reagirem a eventos. Motores de workflow duráveis tornam os orquestradores à prova de quedas.
Quiz da aula
7 perguntas · aprovação com 5 acertos · até 50 XP
Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.
Pratique: simule padrões de microsserviços com Python
Crie pequenas simulações em Python dos padrões, como roteadores, sagas, outboxes, circuit breakers e traces, e execute-as com entradas de exemplo. Elas rodam localmente no navegador; não é preciso ter servidores nem contêineres.
Rode a saga
Cada linha da entrada é uma etapa da saga Service | action | compensation (a compensação é - se a etapa não puder ser desfeita); a última linha é fail: N (começando em 1) ou fail: none. Rode a saga: imprima ✓ Service: action para cada etapa concluída, ✗ Service: action para a que falhou e depois, para cada etapa concluída na ordem inversa, ↩ Service: compensation ou ⚠ Service: cannot undo action. Termine com outcome: completed, outcome: compensated ou outcome: needs manual repair.
- Pagamento recusado
- Falha no foguete depois de cozinhar
- Caminho feliz
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Um orquestrador com novas tentativas
Cada linha da entrada é uma etapa: Service action compensation retriable|compensatable attempts..., em que attempts são os resultados das tentativas sucessivas (ok, fail). O orquestrador tenta cada etapa até 3 vezes:
- Se uma tentativa der certo, imprima
Service: action (attempt N)e siga em frente. - Se uma etapa compensatable falhar 3 vezes, imprima
Service: action FAILED, compense as etapas concluídas na ordem inversa (undo Service: compensation) e pare comsaga rolled back. - Uma etapa retriable não pode desistir: se ela falhar 3 vezes, imprima
Service: action still failing - parked for manual retrye pare comsaga parked.
Se todas as etapas derem certo, imprima saga completed. Uma etapa com menos tentativas listadas do que as que forem feitas trata as que faltam como ok.
- Pagamento instável, depois sucesso
- Acabou o lámen
- Foguete travado
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Dúvidas sobre esta lição
Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.
Carregando publicações…