Durable execution com Temporal: workflows que sobrevivem a falhas e reinícios

1. O Problema da Execução Confiável em Sistemas Distribuídos

Em sistemas distribuídos, falhas não são exceções — são a regra. Um servidor pode cair no meio de uma transação, uma chamada de rede pode expirar, ou uma exceção inesperada pode interromper o processamento de um pedido. Em cenários críticos como processamento de pagamentos, aprovisionamento de infraestrutura ou orquestração de ETL, essas falhas podem causar perda de dados, estados inconsistentes e retrabalho manual.

Abordagens tradicionais tentam mitigar esses problemas com filas de mensagens (RabbitMQ, SQS), bancos de dados como estado compartilhado e mecanismos de retry manual. No entanto, essas soluções apresentam limitações significativas: o estado em memória é perdido em reinícios, rollbacks são complexos de implementar, e a visibilidade do fluxo de execução é praticamente nula. Desenvolvedores acabam gastando mais tempo lidando com infraestrutura de resiliência do que com a lógica de negócio propriamente dita.

2. O que é Durable Execution e como o Temporal Resolve

Durable execution é um paradigma onde workflows persistem seu estado de execução mesmo após falhas catastróficas. Se um servidor cai, o workflow retoma exatamente do ponto onde parou, sem perda de progresso. O Temporal é a plataforma líder nesse espaço, oferecendo uma arquitetura robusta composta por três componentes principais:

  • Temporal Server: responsável por armazenar o histórico de eventos, gerenciar timers e coordenar a execução
  • Worker: processo que executa o código do workflow e das atividades
  • Client: API para iniciar, sinalizar e consultar workflows

A diferença fundamental do Temporal está na separação entre lógica de negócio (workflow) e execução (worker). O workflow define o que deve ser feito, enquanto o worker executa como fazer, com garantias de durabilidade fornecidas pelo servidor.

3. Estrutura de um Workflow Temporal

Um workflow Temporal é código imperativo que define a orquestração de tarefas. As unidades de trabalho são chamadas de Activities, que possuem suporte nativo a retry, timeouts e heartbeats.

Exemplo prático: workflow de processamento de pedido com múltiplas etapas.

import { Workflow } from '@temporalio/workflow';
import * as activities from './activities';

export async function processOrderWorkflow(orderId: string): Promise<string> {
  // Etapa 1: Validar pedido
  const validationResult = await activities.validateOrder(orderId);

  // Etapa 2: Processar pagamento
  const paymentResult = await activities.processPayment(orderId, validationResult.amount);

  // Etapa 3: Atualizar inventário
  await activities.updateInventory(orderId, validationResult.items);

  // Etapa 4: Notificar cliente
  await activities.sendNotification(orderId, paymentResult.transactionId);

  return `Pedido ${orderId} processado com sucesso`;
}

// Definição das activities com retry automático
export const activities = {
  validateOrder: async (orderId: string): Promise<OrderValidation> => {
    // Lógica de validação
  },
  processPayment: async (orderId: string, amount: number): Promise<PaymentResult> => {
    // Lógica de pagamento com retry
  },
  updateInventory: {
    fn: async (orderId: string, items: Item[]) => {
      // Atualização de estoque
    },
    retry: {
      initialInterval: '1 second',
      maximumAttempts: 5,
    },
  },
};

4. Garantias de Durabilidade e Consistência

O Temporal garante durabilidade através de dois mecanismos principais: replays determinísticos e histórico de eventos imutável.

Quando um workflow é executado, cada decisão tomada (chamada de atividade, timer, branch condicional) é registrada como um evento no histórico do workflow. Se o worker falha e reinicia, o Temporal faz um replay de todos os eventos anteriores para reconstruir o estado exato do workflow, antes de continuar a execução do ponto onde parou.

Para que o replay funcione corretamente, o código do workflow deve ser determinístico — ou seja, dado o mesmo histórico de eventos, deve produzir exatamente as mesmas decisões. Operações não determinísticas, como chamadas a APIs externas ou geração de números aleatórios, devem ser encapsuladas em activities ou usar funções especiais como sideEffect e mutableSideEffect.

import { sideEffect } from '@temporalio/workflow';

export async function deterministicWorkflow(): Promise<void> {
  // sideEffect garante que o valor seja registrado no histórico
  const randomValue = await sideEffect(() => Math.random());

  // Apenas a primeira execução gera o número aleatório
  // Replays reutilizam o valor já registrado
}

5. Padrões Avançados com Temporal

O Temporal suporta padrões complexos de orquestração que seriam extremamente difíceis de implementar manualmente.

Sagas Distribuídas: Compensação automática com rollback em atividades. Se uma etapa falha após várias bem-sucedidas, as compensações são executadas automaticamente.

export async function sagaWorkflow(): Promise<void> {
  try {
    await activities.reserveHotel();
    await activities.bookFlight();
    await activities.processPayment();
  } catch (error) {
    // Compensações automáticas
    await activities.cancelFlight();
    await activities.cancelHotel();
    throw error;
  }
}

Workflows Filhos: Modularização e isolamento de falhas. Workflows complexos podem ser decompostos em sub-workflows independentes.

import { executeChild } from '@temporalio/workflow';

export async function parentWorkflow(): Promise<void> {
  const result = await executeChild('childWorkflow', {
    args: ['param1'],
    workflowId: `child-${Date.now()}`,
  });
}

Timers e Delays: Agendamento preciso com garantia de execução mesmo após reinício. Um timer de 24 horas sobrevive a quedas do servidor.

import { sleep } from '@temporalio/workflow';

export async function delayedWorkflow(): Promise<void> {
  await activities.sendReminder();
  await sleep('24 hours'); // Sobrevive a reinícios
  await activities.sendFollowUp();
}

6. Observabilidade e Debugging em Produção

Um dos maiores diferenciais do Temporal é a visibilidade completa da execução dos workflows.

Temporal Web UI: Interface gráfica que mostra o histórico completo de cada workflow, incluindo eventos, timers e atividades executadas. É possível ver exatamente onde uma falha ocorreu e qual era o estado naquele momento.

SDK Tracing: Integração nativa com OpenTelemetry para rastreamento distribuído de chamadas entre workflows, activities e serviços externos.

Estratégias de Teste: O Temporal fornece TestWorkflowEnvironment para simular falhas e testar cenários complexos sem depender de infraestrutura real.

import { TestWorkflowEnvironment } from '@temporalio/testing';

const testEnv = await TestWorkflowEnvironment.create();
const worker = await testEnv.createWorker({
  workflowsPath: './workflows',
  activities: mockActivities,
});

const client = testEnv.client;
const result = await client.execute('processOrderWorkflow', {
  args: ['order-123'],
});

7. Quando Usar Temporal vs Alternativas

O Temporal não substitui todas as ferramentas de mensageria, mas brilha em cenários específicos.

Comparação com filas tradicionais (RabbitMQ, SQS): Filas são excelentes para comunicação assíncrona simples, mas não oferecem orquestração stateful. Com Temporal, você tem visibilidade do fluxo completo, retry automático e compensações.

Comparação com orquestradores (Step Functions, Airflow): Step Functions oferece orquestração baseada em JSON, mas é limitado em lógica condicional complexa. Airflow é ótimo para pipelines de dados, mas não foi projetado para microserviços com baixa latência.

Casos de uso ideais:
- Processamento de pagamentos com múltiplas etapas e compensações
- Aprovisionamento de infraestrutura em nuvem
- ETL complexo com recuperação de falhas
- Fluxos de onboarding de usuários com múltiplos serviços

Custos e trade-offs: O Temporal adiciona latência (tipicamente 10-50ms por decisão) em comparação com execução direta, mas oferece resiliência e visibilidade incomparáveis. Para sistemas críticos onde falhas custam caro, o investimento compensa rapidamente.

O Temporal representa uma mudança de paradigma na construção de sistemas distribuídos confiáveis. Ao invés de lutar contra falhas com código complexo de resiliência, desenvolvedores podem se concentrar na lógica de negócio, confiando que o Temporal cuidará da durabilidade e consistência. Com suporte a múltiplas linguagens (TypeScript, Go, Java, Python, .NET) e uma comunidade ativa, é a escolha certa para quem precisa de workflows que realmente sobrevivem a falhas e reinícios.

Referências