Crie aplicativos de várias etapas e fluxos de trabalho de IA com funções duráveis ​​do AWS Lambda

As aplicações modernas exigem cada vez mais uma coordenação complexa e demorada entre serviços, como processamento de pagamentos em várias etapas, orquestração de agentes de IA ou processos de aprovação que aguardam decisões humanas. Construí-los tradicionalmente exigia um esforço significativo para implementar o gerenciamento de estado, lidar com falhas e integrar vários serviços de infraestrutura.

A partir de hoje, você pode usar Funções duráveis ​​do AWS Lambda para criar aplicativos confiáveis ​​de várias etapas diretamente na experiência acquainted do AWS Lambda. Funções duráveis ​​são funções regulares do Lambda com o mesmo manipulador de eventos e integrações que você já conhece. Você escreve código sequencial em sua linguagem de programação preferida e funções duráveis ​​rastreiam o progresso, tentam novamente automaticamente em caso de falhas e suspendem a execução por até um ano em pontos definidos, sem pagar por computação ociosa durante as esperas.

As funções duráveis ​​do AWS Lambda usam um mecanismo de ponto de verificação e repetição, conhecido como execução durável, para fornecer esses recursos. Depois de habilitar uma função para execução durável, você adiciona o novo SDK de execução durável de código aberto ao seu código de função. Em seguida, você usa primitivos do SDK como “etapas” para adicionar pontos de verificação automáticos e novas tentativas à sua lógica de negócios e “espera” para suspender a execução com eficiência sem custos de computação. Quando a execução termina inesperadamente, o Lambda retoma a partir do último ponto de verificação, reproduzindo seu manipulador de eventos desde o início enquanto ignora as operações concluídas.

Conceitos básicos das funções duráveis ​​do AWS Lambda

Deixe-me explicar como usar funções duráveis.

Primeiro, eu crio um novo Função Lambda no console e selecione Autor do zero. No Execução durável seção, eu seleciono Habilitar. Observe que a configuração da função durável só pode ser definida durante a criação da função e atualmente não pode ser modificada para funções Lambda existentes.

Depois de criar minha função durável do Lambda, posso começar com o código fornecido.

As funções duráveis ​​do Lambda introduzem duas primitivas principais que lidam com gerenciamento e recuperação de estado:

• Passos-O context.step() adiciona novas tentativas automáticas e pontos de verificação à sua lógica de negócios. Após a conclusão de uma etapa, ela será ignorada durante a reprodução.
• Espere-O context.wait() O método pausa a execução por um período especificado, encerrando a função, suspendendo e retomando a execução sem cobranças de computação.

Além disso, as funções duráveis ​​do Lambda fornecem outras operações para padrões mais complexos: create_callback() cria um retorno de chamada que você pode usar para aguardar resultados de eventos externos, como respostas de API ou aprovações humanas, wait_for_condition() faz uma pausa até que uma condição específica seja atendida, como pesquisar uma API REST para conclusão do processo, e parallel() ou map() operações para casos de uso de simultaneidade avançados.

Construindo um fluxo de trabalho de processamento de pedidos pronto para produção

Agora vamos expandir o exemplo padrão para criar um fluxo de trabalho de processamento de pedidos pronto para produção. Isso demonstra como usar retornos de chamada para aprovações externas, lidar com erros adequadamente e configurar estratégias de repetição. Mantenho o código intencionalmente conciso para focar nesses conceitos básicos. Em uma implementação completa, você poderia aprimorar a etapa de validação com Base Amazônica para adicionar análise de pedidos baseada em IA.

Veja como funciona o fluxo de trabalho de processamento de pedidos:

• Primeiro, validate_order() verifica os dados do pedido para garantir que todos os campos obrigatórios estejam presentes.
• Próximo, send_for_approval() envia o pedido para aprovação humana externa e aguarda uma resposta de retorno de chamada, suspendendo a execução sem cobranças de computação.
• Então, process_order() conclui o processamento do pedido.
• Em todo o fluxo de trabalho, o tratamento de erros try-catch distingue entre erros de terminal que interrompem a execução imediatamente e erros recuperáveis ​​dentro de etapas que acionam novas tentativas automáticas.

Aqui está o fluxo de trabalho completo de processamento de pedidos com definições de etapas e o manipulador principal:

import random
from aws_durable_execution_sdk_python import (
    DurableContext,
    StepContext,
    durable_execution,
    durable_step,
)
from aws_durable_execution_sdk_python.config import (
    Period,
    StepConfig,
    CallbackConfig,
)
from aws_durable_execution_sdk_python.retries import (
    RetryStrategyConfig,
    create_retry_strategy,
)


@durable_step
def validate_order(step_context: StepContext, order_id: str) -> dict:
    """Validates order knowledge utilizing AI."""
    step_context.logger.data(f"Validating order: {order_id}")
    # In manufacturing: calls Amazon Bedrock to validate order completeness and accuracy
    return {"order_id": order_id, "standing": "validated"}


@durable_step
def send_for_approval(step_context: StepContext, callback_id: str, order_id: str) -> dict:
    """Sends order for approval utilizing the offered callback token."""
    step_context.logger.data(f"Sending order {order_id} for approval with callback_id: {callback_id}")
    
    # In manufacturing: ship callback_id to exterior approval system
    # The exterior system will name Lambda SendDurableExecutionCallbackSuccess or
    # SendDurableExecutionCallbackFailure APIs with this callback_id when approval is full
    
    return {
        "order_id": order_id,
        "callback_id": callback_id,
        "standing": "sent_for_approval"
    }


@durable_step
def process_order(step_context: StepContext, order_id: str) -> dict:
    """Processes the order with retry logic for transient failures."""
    step_context.logger.data(f"Processing order: {order_id}")
    # Simulate flaky API that generally fails
    if random.random() > 0.4:
        step_context.logger.data("Processing failed, will retry")
        elevate Exception("Processing failed")
    return {
        "order_id": order_id,
        "standing": "processed",
        "timestamp": "2025-11-27T10:00:00Z",
    }


@durable_execution
def lambda_handler(occasion: dict, context: DurableContext) -> dict:
    strive:
        order_id = occasion.get("order_id")
        
        # Step 1: Validate the order
        validated = context.step(validate_order(order_id))
        if validated("standing") != "validated":
            elevate Exception("Validation failed")  # Terminal error - stops execution
        context.logger.data(f"Order validated: {validated}")
        
        # Step 2: Create callback
        callback = context.create_callback(
            title="awaiting-approval",
            config=CallbackConfig(timeout=Period.from_minutes(3))
        )
        context.logger.data(f"Created callback with id: {callback.callback_id}")
        
        # Step 3: Ship for approval with the callback_id
        approval_request = context.step(send_for_approval(callback.callback_id, order_id))
        context.logger.data(f"Approval request despatched: {approval_request}")
        
        # Step 4: Await the callback outcome
        # This blocks till exterior system calls SendDurableExecutionCallbackSuccess or SendDurableExecutionCallbackFailure
        approval_result = callback.outcome()
        context.logger.data(f"Approval obtained: {approval_result}")
        
        # Step 5: Course of the order with customized retry technique
        retry_config = RetryStrategyConfig(max_attempts=3, backoff_rate=2.0)
        processed = context.step(
            process_order(order_id),
            config=StepConfig(retry_strategy=create_retry_strategy(retry_config)),
        )
        if processed("standing") != "processed":
            elevate Exception("Processing failed")  # Terminal error
        
        context.logger.data(f"Order efficiently processed: {processed}")
        return processed
        
    besides Exception as error:
        context.logger.error(f"Error processing order: {error}")
        elevate error  # Re-raise to fail the execution

Este código demonstra vários conceitos importantes:

• Tratamento de erros—O bloco try-catch lida com erros de terminal. Quando uma exceção não tratada é lançada fora de uma etapa (como a verificação de validação), ela encerra a execução imediatamente. Isso é útil quando não há sentido em tentar novamente, como dados de pedido inválidos.
• Novas tentativas de etapa—Dentro do process_order etapa, as exceções acionam novas tentativas automáticas com base no padrão (etapa 1) ou configurado RetryStrategy (etapa 5). Isso lida com falhas transitórias, como indisponibilidade temporária da API.
• Registro—Eu uso context.logger para o manipulador principal e step_context.logger passos internos. O criador de logs de contexto suprime logs duplicados durante a reprodução.

Agora eu crio um evento de teste com order_id e invocar a função de forma assíncrona para iniciar o fluxo de trabalho do pedido. Eu navego até o Teste guia e preencha o opcional Nome de execução durável para identificar esta execução. Observe que funções duráveis ​​fornecem idempotência integrada. Se eu invocar a função duas vezes com o mesmo nome de execução, a segunda invocação retornará o resultado da execução existente em vez de criar uma duplicata.

Posso monitorar a execução navegando até o Execuções duráveis guia no console do Lambda:

Aqui posso ver o standing e o tempo de cada etapa. A execução mostra CallbackStarted seguido pela InvocationCompletedque indica que a função foi encerrada e a execução suspensa para evitar cobranças de inatividade enquanto aguarda o retorno de chamada de aprovação.

Agora posso completar o retorno de chamada diretamente do console escolhendo Enviar sucesso ou Falha no envioou programaticamente usando a API Lambda.

eu escolho Enviar sucesso.

Após a conclusão do retorno de chamada, a execução é retomada e processa o pedido. Se o process_order etapa falha devido à API fragmentada simulada, ela tenta novamente com base na estratégia configurada. Depois que todas as tentativas forem bem-sucedidas, a execução será concluída com êxito.

Monitoramento de execuções com Amazon EventBridge

Você também pode monitorar execuções de funções duráveis ​​usando o Amazon EventBridge. O Lambda envia automaticamente eventos de alteração de standing de execução para o barramento de eventos padrão, permitindo criar fluxos de trabalho downstream, enviar notificações ou integrar-se a outros serviços da AWS.

Para receber esses eventos, crie uma regra EventBridge no barramento de eventos padrão com este padrão:

{
  "supply": ("aws.lambda"),
  "detail-type": ("Sturdy Execution Standing Change")
}

Coisas para saber

Aqui estão os pontos principais a serem observados:

• Disponibilidade—As funções duráveis ​​do Lambda agora estão disponíveis na região da AWS Leste dos EUA (Ohio). Para obter a disponibilidade mais recente da região, visite o Capacidades da AWS por região página.
• Suporte a linguagem de programação—No lançamento, as funções duráveis ​​do AWS Lambda oferecem suporte a JavaScript/TypeScript (Node.js 22/24) e Python (3.13/3.14). Recomendamos agrupar o SDK de execução durável com seu código de função usando seu gerenciador de pacotes preferido. Os SDKs são rápidos, então você pode atualizar facilmente as dependências à medida que novos recursos são disponibilizados.
• Usando versões Lambda—Ao implantar funções duráveis ​​na produção, use versões do Lambda para garantir que a reprodução sempre aconteça na mesma versão de código. Se você atualizar seu código de função enquanto uma execução estiver suspensa, a reprodução usará a versão que iniciou a execução, evitando inconsistências decorrentes de alterações de código durante fluxos de trabalho de longa execução.
• Testando suas funções duráveis—Você pode testar funções duráveis ​​localmente sem credenciais da AWS usando o SDK de teste separado com integração pytest e o Interface de linha de comando (CLI) do AWS Serverless Software Mannequin (AWS SAM) para testes de integração mais complexos.
• SDKs de código aberto—Os SDKs de execução duráveis ​​são de código aberto para JavaScript/TypeScript e Pitão. Você pode revisar o código-fonte, contribuir com melhorias e ficar atualizado com os recursos mais recentes.
• Preços—Para saber mais sobre os preços das funções duráveis ​​do AWS Lambda, consulte o Preços do AWS Lambda página.

Comece a usar as funções duráveis ​​do AWS Lambda visitando o Console AWS Lambda. Para saber mais, consulte Funções duráveis ​​do AWS Lambda página de documentação.

Feliz edifício!

– Donnie