O blog da AWS

Construindo aplicações tolerantes a falhas com funções duráveis do AWS Lambda

Por Rahul Pisal, Sr. Solutions Architect e Ben Freiberg, Sr. Solutions Architect.

Aplicações de negócios frequentemente coordenam múltiplas etapas que precisam ser executadas de forma confiável ou aguardar por períodos prolongados, como integração de clientes, processamento de pagamentos ou orquestração de inferência de modelos de linguagem grandes. Esses processos críticos requerem conclusão apesar de interrupções temporárias ou falhas do sistema. Atualmente, desenvolvedores gastam tempo significativo implementando mecanismos para rastrear progresso, lidar com falhas e gerenciar recursos ao aguardar eventos externos, desviando o foco da lógica de negócios para tarefas indiferenciadas.

No re:Invent 2025, Amazon Web Services (AWS) lançou AWS Lambda funções duráveis, uma nova capacidade que estende o modelo de programação orientado a eventos do Lambda com capacidades integradas para construir aplicações multi-etapas tolerantes a falhas e fluxos de trabalho de IA usando linguagens de programação familiares. Em sua essência, funções duráveis são funções Lambda regulares, portanto seus processos de desenvolvimento e operacionais para Lambda continuam a se aplicar. No entanto, ao criar uma função Lambda você agora pode ativar execução durável, para que possa criar pontos de verificação de progresso, recuperar automaticamente de falhas e suspender a execução por até um ano ao aguardar tarefas de longa duração, como processos com intervenção humana.

Como funcionam as funções duráveis do Lambda

Ao trabalhar com funções Lambda padrão, seu código é executado do início ao fim em uma única invocação. Se uma falha ocorrer em qualquer ponto durante a execução, a função inteira deve ser repetida pela fonte de evento invocadora. Qualquer estado que precise ser preservado entre execuções deve ser explicitamente salvo e recuperado. Isso é tipicamente feito usando serviços de armazenamento externos como Amazon DynamoDB ou Amazon Simple Storage Service (Amazon S3). Além disso, você deve tipicamente proteger contra invocações duplicadas (concorrentes) do mesmo evento e ter uma estratégia para implantar atualizações com segurança enquanto continua a processar eventos.

Em contraste, com funções duráveis do Lambda, desenvolvedores usam operações duráveis como “Steps” e “Waits” no handler de eventos para criar pontos de verificação de progresso, lidar com falhas e suspender a execução durante períodos de espera sem incorrer em cobranças de computação para funções sob demanda. Essas operações duráveis e qualquer estado opcional retornado delas são automaticamente persistidos pelo Lambda em um backend de execução durável totalmente gerenciado. Se falhas ocorrerem durante a execução, ou se sua função retomar sua execução após ser pausada, o Lambda invoca sua função novamente, restaurando (reproduzindo) o estado anterior executando o handler de eventos desde o início, mas pulando operações duráveis concluídas. Para simplificar esse mecanismo de ponto de verificação/reprodução para desenvolvedores, você pode usar o SDK de execução durável do Lambda para envolver ou anotar seu handler de eventos, que enriquece o contexto Lambda existente com vários novos métodos como context.step() e context.wait(). Além disso, você pode usar métodos como context.waitForCallback() para aguardar trabalhos externos ou processos assíncronos, como cenários de “intervenção humana”. A execução é pausada até que uma resposta SendDurableExecutionCallbackSuccess ou SendDurableExecutionCallbackFailure seja enviada para a API do Lambda.

Introdução

Use o AWS Serverless Application Model (AWS SAM) para criar uma nova função durável com sam init com um AWS Quick Start Template. Funções duráveis do Lambda também são suportadas pelo AWS Cloud Development Kit (AWS CDK), AWS Command Line Interface (AWS CLI), AWS CloudFormation e outros frameworks de infraestrutura como código (IaC) como Terraform.

Veja a seguinte função, que realiza integração de usuário. Primeiro, ela cria um perfil de usuário baseado em alguns dados, então envia um e-mail para verificação e aguarda até que o usuário confirme o endereço de e-mail, ou um timeout de 24 horas seja atingido. Finalmente, ela envia uma confirmação.

import {
  DurableContext,
  withDurableExecution,
} from '@aws/durable-execution-sdk-js';
export const handler = withDurableExecution(
  async (event: OnboardingEvent, context: DurableContext) => {
    try {    
      // Create user profile
      const profile = await context.step("create-profile", async () =>
        createUserProfile(event.email, event.name)
      );
      // Wait for email verification via callback
      const verification = await context.waitForCallback(
        "wait-for-email-verification",
        async (callbackId) => {
          // Send email to user and pass callbackId
          await sendVerificationEmail(profile, callbackId);
        },
        {
          timeout: { hours: 24 } 
        }
      );
      // Send confirmation and welcome email
      const result = await context.step("complete-onboarding", async () => {
        if (!verification || !verification.verified) 
     return { ...profile, status: 'failed' };
        await sendWelcomeEmail(profile.email, profile.name);
        return { ...profile, status: 'active' };
      });
      return result;
    } catch (error) {
      // omitted 
    }
  }
);

Funções duráveis têm tratamento de erros integrado e totalmente personalizável para etapas. Por exemplo, se o perfil foi criado e verificado com sucesso, mas um erro temporário ocorreu ao enviar a confirmação, então a etapa é repetida. A repetição pula quaisquer pontos de verificação concluídos anteriormente, como a criação do perfil e callback. Apenas o código dentro da etapa de envio de confirmação é executado novamente.

Em seguida, você atualiza o template do AWS SAM para incluir sua função durável. Você cria uma função durável do Lambda incluindo a configuração DurableConfig para sua função. Note que atualmente você não pode adicionar uma configuração durável a uma função que foi originalmente criada sem ela. O ExecutionTimeout define após quanto tempo a execução durável expira para proteger contra bugs de aplicação descontrolados ou em deadlock. Esta configuração é separada do timeout de invocação, que define por quanto tempo uma única invocação pode ser executada. O timeout máximo de invocação para uma única invocação de função permanece inalterado em 15 minutos. Com funções duráveis do Lambda, você tipicamente verá múltiplas invocações por execução durável, como ao usar as capacidades de espera no SDK ou repetições automáticas. Você pode definir o ExecutionTimeout para até um ano ao usar invocações assíncronas.

O RetentionPeriodInDays define por quanto tempo os dados de execução de uma execução durável estão disponíveis para você após as execuções serem concluídas.

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
 
Resources:
  UserOnboardingFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: UserOnboardingFunction
      CodeUri: ./src
      Handler: index.handler
      Runtime: nodejs24.x
      Architectures:
        - x86_64
      MemorySize: 256
      Timeout: 60		   // Timeout for an individual invocation
      DurableConfig:		   // This makes the function a durable function
        ExecutionTimeout: 90000 // 25h timeout for the durable execution overall
        RetentionPeriodInDays: 7 
UserOnboardingFunctionRole:
    Type: AWS::IAM::Role
    // omitted for brevity

Você deve incluir as permissões necessárias para sua função. Por exemplo, a política gerenciada AWSLambdaBasicDurableExecutionRole permite apenas as ações mínimas do AWS Identity and Access Management (IAM) para criar/recuperar pontos de verificação e logs para aumentar a segurança. Portanto, ela não inclui permissões para invocar outras funções (duráveis) ou gerenciar callbacks. Consulte a documentação para mais detalhes.

Testando localmente

Antes de implantar sua função, você pode testá-la localmente usando AWS SAM local invoke.

O AWS SAM invoca localmente sua função e executa o handler de eventos até atingir o context.waitForCallback(). Para completar callbacks, o AWS SAM oferece novos comandos para interagir com suas funções duráveis. Neste exemplo, você envia uma resposta de Success para completar o callback. Você também pode incluir dados relevantes na resposta. Você pode enviar a resposta diretamente usando o guia na tela ou usando outro comando AWS SAM CLI de outro processo.

sam local callback succeed <your-callback-id> --result '<your data>'

Para inspecionar uma execução, você pode usar o AWS SAM para recuperar o histórico de execução durável de sua função, que inclui detalhes sobre etapas, callbacks e durações de espera, como mostrado no código de exemplo a seguir.

sam local execution history <execution-arn>

Dependendo do seu caso de uso, você pode em vez disso enviar uma resposta de Failure para um callback e lidar com esses erros em seu código. Por exemplo, executando lógica de compensação em uma etapa subsequente:

sam local callback fail <your-callback-id> --result '<your data>'

Agora que você verificou que sua função opera conforme pretendido, implante-a na AWS usando o comando sam deploy.

Melhores práticas e considerações

Invocar uma função durável do Lambda requer um Amazon Resource Name (ARN), qualificado, como um alias ou versão. Recomendamos não usar o qualificador $LATEST exceto para prototipagem rápida ou testes locais. Usar versões explícitas garante que as reproduções sempre aconteçam com o mesmo código com o qual a execução foi iniciada. Isso garante execução determinística e previne inconsistências ao atualizar o código de sua função durante as execuções.

Recomendamos incluir o SDK de execução durável com o código de sua função usando seu gerenciador de pacotes preferido. Os SDKs evoluem rapidamente, então você pode atualizar dependências à medida que novos recursos se tornam disponíveis.

Existem outras operações duráveis no SDK de funções duráveis do Lambda que você pode usar para construir sua aplicação:

  • waitForCondition(): Pausa a execução de sua função até que uma condição seja atendida. Por exemplo, o status de um trabalho consultado com uma API. Para isso funcionar, você fornece a waitStrategy e uma função de verificação para consultar o status.
  • parallel(): Executa múltiplas operações duráveis em paralelo dentro da mesma função, com opções configuráveis como o número máximo de ramificações concorrentes e comportamento de falha desejado. Isso simplifica o gerenciamento de durabilidade e criação de pontos de verificação para ações assíncronas simultâneas.
  • map(): Cria uma operação durável e ponto de verificação para cada item de um array, baseado na função de mapeamento fornecida. Os itens são processados concorrentemente.
  • invoke(): Invoca outra função Lambda e aguarda seu resultado. O SDK cria um ponto de verificação, invoca a função alvo e retoma sua função quando a invocação é concluída. Isso ativa composição de funções e decomposição de fluxo de trabalho.

Consulte o guia de desenvolvimento para mais detalhes.

Cobranças de computação do Lambda aplicam-se a todas as invocações, incluindo quaisquer reproduções. Ao usar operações de espera, a função suspende a execução e, para funções sob demanda, não gera cobranças de duração até que a execução seja retomada. Você também é cobrado por operações duráveis, dados gravados e retenção de dados. Para mais informações sobre preços de funções duráveis do Lambda, consulte a página de preços do Lambda.

Para a disponibilidade mais recente por Região, visite a página de Capacidades da AWS por Região.

Conclusão

Funções duráveis do AWS Lambda estendem o modelo de programação do Lambda para simplificar a construção de aplicações tolerantes a falhas e de longa duração usando padrões de programação familiares. Você pode usar funções duráveis do Lambda para escrever fluxos de trabalho multi-etapas em sua linguagem de programação preferida, usando métodos integrados que automaticamente lidam com criação de pontos de verificação de progresso e recuperação de erros. Isso simplifica suas arquiteturas para que você possa focar em sua lógica de negócios e otimizar custos cobrando apenas pelo tempo de computação ativo.

Você pode construir funções duráveis para funções Lambda baseadas em Python ou Node.js usando a API do Lambda, AWS Management Console, AWS CLI, AWS CloudFormation, AWS SAM, AWS SDK e AWS CDK.

Para iniciar, visite o Guia do Desenvolvedor do Lambda ou assista à sessão breakout do re:Invent.

Este conteúdo foi traduzido do post original do blog, que pode ser encontrado aqui.

Autores

Rahul Pisal, Sr. Solutions Architect
Ben Freiberg, Sr. Solutions Architect

Tradutores

Rodrigo Peres é Arquiteto de Soluções na AWS, com mais de 20 anos de experiência trabalhando com arquitetura de soluções, desenvolvimento de sistemas e modernização de sistemas legados.

Daniel Abib é arquiteto de soluções sênior na AWS, com mais de 25 anos trabalhando com gerenciamento de projetos, arquiteturas de soluções escaláveis, desenvolvimento de sistemas e CI/CD, microsserviços, arquitetura Serverless & Containers e segurança. Ele trabalha apoiando clientes corporativos, ajudando-os em sua jornada para a nuvem.

https://www.linkedin.com/in/danielabib/