Carregando
0x60Lição 7 de 15

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.

30 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • 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 XP

Simulador 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. 1. Pedidoscriar o pedido (pendente)desfazer: cancelar o pedido
  2. 2. Pagamentoscobrar o cartãodesfazer: estornar o cartão
  3. 3. Cozinhareservar os ingredientesdesfazer: liberar os ingredientes
  4. 4. Cozinhacozinhar o lámennão pode ser desfeito
  5. 5. Entregalançar o foguetenão pode ser desfeito

Log da saga

  1. ✓Pedidos: criar o pedido (pendente)
  2. ✓Pagamentos: cobrar o cartão
  3. ✓Cozinha: reservar os ingredientes
  4. ✓Cozinha: cozinhar o lámen
  5. ✓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:

  1. Primeiro as etapas compensáveis - o que pode ser desfeito.
  2. O pivot - o ponto sem volta.
  3. 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çãoCoreografia
Quem decide a próxima etapaum orquestrador central envia comandos (ChargeCard) e espera as respostascada serviço reage aos eventos do serviço anterior (OrderCreated → Pagamentos cobra)
Onde o fluxo fica visívelnum só lugar - a máquina de estados do orquestradorespalhado pelos serviços; você o reconstrói a partir dos eventos
Acoplamentoos serviços dependem dos comandos do orquestradoros serviços dependem só dos eventos
Bom parafluxos complexos, com muitas etapas e ramificaçõesfluxos 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.

orchestrator.py
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))
Saída
  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.

Exercício 1

Rode a saga

+25 XP

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
main.py
Carregando editor…

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.

Exercício 2

Um orquestrador com novas tentativas

+25 XP

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 com saga rolled back.
  • Uma etapa retriable não pode desistir: se ela falhar 3 vezes, imprima Service: action still failing - parked for manual retry e pare com saga 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
main.py
Carregando editor…

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…