Potência igual

As funções duráveis fornecem idempotência integrada para o início da execução por meio de nomes de execução. Quando você fornece um nome de execução, o Lambda o usa para evitar execuções duplicadas e permitir novas tentativas seguras de solicitações de invocação. Por padrão, as etapas têm semântica de execução de pelo menos uma vez. Durante a reprodução, o SDK retorna resultados verificados sem reexecutar as etapas concluídas, mas sua lógica de negócios deve ter idempotência para lidar com possíveis novas tentativas antes da conclusão.

Nomes de execuções

É possível fornecer um nome de execução ao invocar uma função durável. O nome da execução atua como uma chave de idempotência, permitindo que você repita com segurança as solicitações de invocação sem criar execuções duplicadas. Se você não fornecer um nome, o Lambda gerará automaticamente um ID de execução exclusivo.

Os nomes de execução deves ser exclusivos na sua conta e na sua região atual. Quando você invoca uma função com um nome de execução que já existe, o comportamento do Lambda depende do estado da execução existente e da correspondência da carga útil.

Comportamento de idempotência

A tabela a seguir descreve como o Lambda lida com solicitações de invocação com base no fato de você fornecer um nome de execução, no estado de execução existente e na correspondência da carga útil:

Observação

Os cenários 3 e 5 demonstram um comportamento com idempotência em que o Lambda lida com segurança com solicitações de invocação duplicadas, retornando as informações de execução existentes em vez de criar duplicatas.

Idempotência de etapas

Por padrão, as etapas têm semântica de execução de ao menos uma vez. Quando sua função é reproduzida após uma espera, um retorno de chamada ou uma falha, o SDK compara cada etapa com base no log do ponto de verificação. Para etapas que já foram concluídas, o SDK retorna o resultado do checkpoint sem reexecutar a lógica da etapa. No entanto, se uma etapa falhar ou a função for interrompida antes da conclusão da etapa, a etapa poderá ser executada várias vezes.

Sua lógica de negócios encapsulada em etapas deve ter idempotência para lidar com possíveis novas tentativas. Use chaves de idempotência para garantir que operações como pagamentos ou gravações de banco de dados sejam executadas somente uma vez, mesmo que a etapa sofra uma nova tentativa.

Exemplo: uso de chaves de idempotência em etapas

TypeScript

import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
import { randomUUID } from 'crypto';

export const handler = withDurableExecution(
  async (event: any, context: DurableContext) => {
    // Generate idempotency key once
    const idempotencyKey = await context.step('generate-key', async () => {
      return randomUUID();
    });
    
    // Use idempotency key in payment API to prevent duplicate charges
    const payment = await context.step('process-payment', async () => {
      return paymentAPI.charge({
        amount: event.amount,
        idempotencyKey: idempotencyKey
      });
    });
    
    return { statusCode: 200, payment };
  }
);
          

Python

from aws_durable_execution_sdk_python import durable_execution, DurableContext
import uuid

@durable_execution
def handler(event, context: DurableContext):
    # Generate idempotency key once
    idempotency_key = context.step(
        lambda _: str(uuid.uuid4()),
        name='generate-key'
    )
    
    # Use idempotency key in payment API to prevent duplicate charges
    payment = context.step(
        lambda _: payment_api.charge(
            amount=event['amount'],
            idempotency_key=idempotency_key
        ),
        name='process-payment'
    )
    
    return {'statusCode': 200, 'payment': payment}
          

É possível configurar etapas para usar a semântica de execução de no máximo uma vez definindo o modo de execução como AT_MOST_ONCE_PER_RETRY. Isso garante que a etapa seja executada no máximo uma vez por nova tentativa, mas pode não ser executada se a função for interrompida antes da conclusão da etapa.

O SDK impõe a reprodução determinística ao validar se os nomes e a ordem das etapas correspondem ao log do ponto de verificação durante a reprodução. Se seu código tentar executar etapas em uma ordem diferente ou com nomes diferentes, o SDK emitirá um NonDeterministicExecutionError

Como a reprodução funciona com etapas concluídas:

Esse mecanismo de reprodução garante que as etapas concluídas não sejam reexecutadas, mas sua lógica de negócios ainda deve ter idempotência para lidar com novas tentativas antes da conclusão.