# Criação de funções duráveis do Lambda
Para começar a usar as funções duráveis do Lambda, use o console do Lambda para criar uma função durável. Em alguns minutos, é possível criar e implantar uma função durável que use etapas e esperas para demonstrar a execução baseada em pontos de verificação.
Ao prosseguir no tutorial, você aprenderá conceitos fundamentais de funções duráveis, como usar o objeto `DurableContext`, criar pontos de verificação com etapas e pausar a execução com esperas. Você também aprenderá como a reprodução funciona quando sua função é retomada após uma espera.
Para simplificar, este tutorial mostra como criar sua função usando o runtime do Python ou do Node.js. Com essas linguagens interpretadas, você pode editar o código da função diretamente no editor de código integrado do console.
**nota**
Atualmente, as funções duráveis oferecem suporte a runtimes de Python, Node.js (JavaScript/TypeScript) e Java, e imagens de contêiner (OCI). Para obter uma lista completa das versões de runtime e opções de imagem de contêiner compatíveis, consulte [Runtimes compatíveis para funções duráveis](durable-supported-runtimes.md). Para obter mais informações sobre como usar imagens de contêiner com o Lambda, consulte [Criação de imagens de contêiner do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) no Guia do desenvolvedor do Lambda.
**dica**
Para saber como construir **soluções com tecnologia sem servidor**, confira o [Guia do desenvolvedor com tecnologia sem servidor](https://docs.aws.amazon.com/serverless/latest/devguide/).
## Pré-requisitos
### Inscrever-se para uma Conta da AWS
Se você ainda não tem uma Conta da AWS, siga as etapas abaixo para criar uma.
**Como cadastrar uma Conta da AWS**
1. Abra [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup).
1. Siga as instruções online.
Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone.
Quando você se inscreve para uma Conta da AWS, um *Usuário raiz da conta da AWS* é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
A AWS envia um e-mail de confirmação depois que o processo de inscrição é concluído. A qualquer momento, é possível exibir as atividades da conta atual e gerenciar sua conta acessando [https://aws.amazon.com/](https://aws.amazon.com/) e selecionando **Minha conta**.
### Criar um usuário com acesso administrativo
Depois de se cadastrar em uma Conta da AWS, proteja seu Usuário raiz da conta da AWS, habilite o Centro de Identidade do AWS IAM e crie um usuário administrativo para não usar o usuário-raiz em tarefas cotidianas.
**Proteger o Usuário raiz da conta da AWS**
1. Faça login no [Console de gerenciamento da AWS](https://console.aws.amazon.com/) como o proprietário da conta ao escolher a opção **Usuário-raiz** e inserir o endereço de e-mail da Conta da AWS. Na próxima página, insira a senha.
Para obter ajuda ao fazer login usando o usuário-raiz, consulte [Fazer login como usuário-raiz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) no *Guia do usuário do Início de Sessão da AWS*.
1. Habilite a autenticação multifator (MFA) para o usuário-raiz.
Para obter instruções, consulte [Habilitar um dispositivo MFA virtual para sua Conta da AWS de usuário-raiz (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) no *Guia do usuário do IAM*.
**Criar um usuário com acesso administrativo**
1. Habilita o Centro de Identidade do IAM.
Para obter instruções, consulte [Habilitar o Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.
1. No Centro de Identidade do IAM, conceda o acesso administrativo a um usuário.
Para obter um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como a fonte de identidade, consulte [Configurar o acesso dos usuários com o Diretório do Centro de Identidade do IAM padrão](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.
**Iniciar sessão como o usuário com acesso administrativo**
+ Para fazer login com o seu usuário do Centro de Identidade do IAM, use o URL de login enviado ao seu endereço de e-mail quando o usuário do Centro de Identidade do IAM foi criado.
Para obter ajuda para fazer login usando um usuário do Centro de Identidade do IAM, consulte [Fazer login no portal de acesso da AWS](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html), no *Guia do usuário do Início de Sessão da AWS*.
**Atribuir acesso a usuários adicionais**
1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo.
Para obter instruções, consulte [Criar um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.
1. Atribua usuários a um grupo e, em seguida, atribua o acesso de logon único ao grupo.
Para obter instruções, consulte [Adicionar grupos](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.
## Criação de uma função durável do Lambda com o console
Neste exemplo, sua função durável processa um pedido por meio de várias etapas com verificação automática. A função usa um objeto JSON contendo um ID do pedido, valida o pedido, processa o pagamento e confirma o pedido. Cada etapa é verificada automaticamente, portanto, se a função for interrompida, ela será retomada a partir da última etapa concluída.
Sua função também demonstra uma operação de espera, pausando a execução por um curto período para simular a espera pela confirmação externa.
**Para criar uma função durável com o console**
1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.
1. Escolha a opção **Criar função**.
1. Selecione **Criar do zero**.
1. No painel **Informações básicas**, para **Nome da função**, insira `myDurableFunction`.
1. Em **Runtime**, escolha **Node.js 24** ou **Python 3.14**.
1. Selecione **Habilitar execução durável**.
O Lambda cria sua função durável com um [perfil de execução](lambda-intro-execution-role.md) que inclui permissões para operações de ponto de verificação (`lambda:CheckpointDurableExecution` e `lambda:GetDurableExecutionState`).
**nota**
Os runtimes do Lambda incluem o SDK de execução durável, para que seja possível testar funções duráveis sem dependências de empacotamento. No entanto, recomendamos incluir o SDK em seu pacote de implantação para produção. Isso garante a consistência da versão e evita possíveis atualizações de runtime que possam afetar sua função.
Use o editor de código embutido do console para adicionar o código da sua função durável.
------
#### [ Node.js ]
**Modificar o código no console**
1. Escolha a guia **Código**.
No editor de código integrado do console, você deve ver o código da função que o Lambda criou. Se você não vir a guia **index.mjs** no editor de código, selecione **index.mjs** no explorador de arquivos, conforme mostrado no diagrama a seguir.
1. Cole o código a seguir na guia **index.mjs**, substituindo o código que o Lambda criou.
```
import {
withDurableExecution,
} from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event, context) => {
const orderId = event.orderId;
// Step 1: Validate order
const validationResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Validating order ${orderId}`);
return { orderId, status: "validated" };
});
// Step 2: Process payment
const paymentResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Processing payment for order ${orderId}`);
return { orderId, status: "paid", amount: 99.99 };
});
// Wait for 10 seconds to simulate external confirmation
await context.wait({ seconds: 10 });
// Step 3: Confirm order
const confirmationResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Confirming order ${orderId}`);
return { orderId, status: "confirmed" };
});
return {
orderId: orderId,
status: "completed",
steps: [validationResult, paymentResult, confirmationResult]
};
}
);
```
1. Na seção **DEPLOY**, escolha **Implantar** para atualizar o código da função:
**Noções básicas sobre o seu código de função durável**
Antes de passar para a próxima etapa, vamos analisar o código da função e compreender alguns conceitos-chave das funções duráveis.
+ O wrapper `withDurableExecution`:
Sua função durável é encapsulada com `withDurableExecution`. Esse encapsulamento permite uma execução durável fornecendo o objeto `DurableContext` e gerenciando as operações de ponto de verificação.
+ O objeto `DurableContext`:
Em vez do contexto padrão do Lambda, sua função recebe um `DurableContext`. Esse objeto fornece métodos para operações duráveis, como `step()` e `wait()`, que criam os pontos de verificação.
+ Etapas e pontos de verificação:
Cada chamada a `context.step()` cria um ponto de verificação antes e depois da execução. Se sua função for interrompida, ela será retomada a partir do último ponto de verificação concluído. A função não executa novamente as etapas concluídas. Em vez disso, ele usa os resultados armazenados.
+ Operações de espera:
A chamada a `context.wait()` pausa a execução sem consumir recursos computacionais. Quando espera é concluída, o Lambda invoca sua função novamente e reproduz o log do ponto de verificação, substituindo os valores armazenados por etapas concluídas.
+ Mecanismo de reprodução:
Quando sua função é retomada após uma espera ou interrupção, o Lambda executa seu código desde o início. Contudo, as etapas concluídas não são reexecutadas. O Lambda reproduz seus resultados a partir do log do ponto de verificação. É por isso que seu código deve ser determinístico.
------
#### [ Python ]
**Modificar o código no console**
1. Escolha a guia **Código**.
No editor de código integrado do console, você deve ver o código da função que o Lambda criou. Se você não vir a guia **lambda\_function.py** no editor de código, selecione **lambda\_function.py** no explorador de arquivos, conforme mostrado no diagrama a seguir.
1. Cole o código a seguir na guia **lambda\_function.py**, substituindo o código que o Lambda criou.
```
from aws_durable_execution_sdk_python import (
DurableContext,
durable_execution,
durable_step,
)
from aws_durable_execution_sdk_python.config import Duration
@durable_step
def validate_order(step_context, order_id):
step_context.logger.info(f"Validating order {order_id}")
return {"orderId": order_id, "status": "validated"}
@durable_step
def process_payment(step_context, order_id):
step_context.logger.info(f"Processing payment for order {order_id}")
return {"orderId": order_id, "status": "paid", "amount": 99.99}
@durable_step
def confirm_order(step_context, order_id):
step_context.logger.info(f"Confirming order {order_id}")
return {"orderId": order_id, "status": "confirmed"}
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
# Step 1: Validate order
validation_result = context.step(validate_order(order_id))
# Step 2: Process payment
payment_result = context.step(process_payment(order_id))
# Wait for 10 seconds to simulate external confirmation
context.wait(Duration.from_seconds(10))
# Step 3: Confirm order
confirmation_result = context.step(confirm_order(order_id))
return {
"orderId": order_id,
"status": "completed",
"steps": [validation_result, payment_result, confirmation_result]
}
```
1. Na seção **DEPLOY**, escolha **Implantar** para atualizar o código da função:
**Noções básicas sobre o seu código de função durável**
Antes de passar para a próxima etapa, vamos analisar o código da função e compreender alguns conceitos-chave das funções duráveis.
+ O decorator `@durable_execution`:
Sua função de manipulador é decorada com `@durable_execution`. Esse decorador permite uma execução durável fornecendo o objeto `DurableContext` e gerenciando as operações de ponto de verificação.
+ O decorator `@durable_step`:
Cada função de etapa é decorada com `@durable_step`. Esse decorador marca a função como uma etapa durável que cria pontos de verificação.
+ O objeto `DurableContext`:
Em vez do contexto padrão do Lambda, sua função recebe um `DurableContext`. Esse objeto fornece métodos para operações duráveis, como `step()` e `wait()`, que criam os pontos de verificação.
+ Etapas e pontos de verificação:
Cada chamada a `context.step()` cria um ponto de verificação antes e depois da execução. Se sua função for interrompida, ela será retomada a partir do último ponto de verificação concluído. A função não executa novamente as etapas concluídas. Em vez disso, ele usa os resultados armazenados.
+ Operações de espera:
A chamada a `context.wait()` pausa a execução sem consumir recursos computacionais. Quando espera é concluída, o Lambda invoca sua função novamente e reproduz o log do ponto de verificação, substituindo os valores armazenados por etapas concluídas.
+ O SDK do Python é síncrono:
Observe que o SDK do Python não usa `await`. Todas as operações duráveis são chamadas de métodos síncronas.
------
## Invocação da função durável usando o editor de códigos do console
Quando nenhuma versão explícita é especificada (ou publicada), o console invoca a função durável usando o qualificador de versão `$LATEST`. No entanto, para a execução determinística do seu código, você deve sempre usar um ARN qualificado apontando para uma versão estável.
**Para publicar uma versão da sua função**
1. Escolha a guia **Versões**.
1. Escolha **Publicar nova versão**.
1. Em **Descrição da versão**, insira **Initial version** (opcional).
1. Selecione **Publish**.
1. O Lambda criará a versão 1 da sua função. Observe que a função do ARN agora inclui `:1` no final, indicando que esta é a versão 1.
Agora, crie um evento de teste para enviar à sua função. O evento é um documento em formato JSON contendo um ID de pedido.
**Criar o evento de teste**
1. Na seção **TEST EVENTS** do editor de código do console, escolha **Criar evento de teste**.
1. Em **Event Name (Nome do evento)**, insira **myTestEvent**.
1. Na seção **JSON do evento**, substitua o JSON padrão pelo seguinte:
```
{
"orderId": "order-12345"
}
```
1. Escolha **Salvar**.
**Para testar sua função durável e visualizar a execução**
Na seção **TEST EVENTS** do editor de código do console, selecione o ícone de execução ao lado do evento de teste:
Sua função durável começará a ser executada. Como ela inclui uma espera de 10 segundos, a invocação inicial é concluída rapidamente e a função será retomada após o período de espera. É possível visualizar o andamento da execução na guia **Execuções duráveis**.
**Para visualizar sua execução da sua função durável**
1. Escolha a guia **Execuções duráveis**.
1. Encontre sua execução na lista. A execução mostra o status atual (Em execução, Com êxito ou Com falha).
1. Escolha o ID da execução para visualizar os detalhes, incluindo:
+ Cronograma de execução, mostrando quando cada etapa foi concluída
+ Histórico dos pontos de verificação
+ Períodos de espera
+ Resultados de etapas
Também é possível visualizar os logs da sua função no CloudWatch Logs para ver a saída do console de cada etapa.
**Para visualizar os registros de invocação da sua função no CloudWatch Logs**
1. Abra a [página Log groups](https://console.aws.amazon.com/cloudwatch/home#logs:) (Grupos de log) do console do CloudWatch.
1. Escolha o nome do grupo de logs para sua função (`/aws/lambda/myDurableFunction`).
1. Role para baixo e selecione o **Fluxo de logs** para as invocações da função que você deseja verificar.
Você verá as entradas de log para cada invocação de sua função, incluindo a execução inicial e a reprodução após a espera.
**nota**
Ao usar o registrador de `DurableContext` (como `context.logger` ou `stepContext.logger`), os registros também aparecem na execução durável e nas visualizações de etapas no console do Lambda. Esses registros podem demorar um pouco para serem carregados.
## Limpeza
Quando você tiver terminado de trabalhar com a função durável de exemplo, exclua-a. Também é possível excluir o grupo de logs que armazena os logs da função e a [função de execução](lambda-intro-execution-role.md) que o console criou.
**Como excluir a função do Lambda**
1. Abra a página [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funções) no console do Lambda.
1. Selecione a função que você criou.
1. Selecione **Ações**, **Excluir**.
1. Digite **confirm** no campo de entrada de texto e escolha **Delete** (Excluir).
**Para excluir o grupo de logs**
1. Abra a [página Log groups](https://console.aws.amazon.com/cloudwatch/home#logs:) (Grupos de log) do console do CloudWatch.
1. Selecione o grupo de logs da função (`/aws/lambda/myDurableFunction`).
1. Selecione **Actions (Ações)**, **Delete log group(s) (Excluir grupo(s) de log)**.
1. Na caixa de diálogo **Delete log group(s)** (Excluir grupo(s) de logs), escolha **Delete** (Excluir).
**Para excluir a função de execução**
1. Abra a [página Roles](https://console.aws.amazon.com/iam/home?#/roles) (Funções) no console do AWS Identity and Access Management (IAM).
1. Selecione o perfil de execução da função (por exemplo, `myDurableFunction-role-{{31exxmpl}}`).
1. Escolha **Excluir**.
1. Na caixa de diálogo **Excluir perfil**, insira o nome do perfil e, em seguida, escolha **Excluir**.
## Recursos adicionais e próximas etapas
Agora que você criou e testou uma função durável simples usando o console, siga estes próximos passos:
+ Saiba mais sobre casos de uso comuns para funções duráveis, incluindo transações distribuídas, processamento de pedidos e fluxos de trabalho de revisão humana. Veja [Exemplos](durable-examples.md).
+ Entenda como monitorar execuções de funções duráveis com as métricas e o histórico de execução do CloudWatch. Consulte [Monitoramento e depuração](durable-monitoring.md).
+ Saiba mais sobre como invocar funções duráveis de forma síncrona e assíncrona e gerenciar execuções de longa duração. Consulte [Invocação de funções duráveis](durable-invoking.md).
+ Siga as práticas recomendadas para escrever código determinístico, gerenciar tamanhos de pontos de verificação e otimizar custos. Consulte as [Práticas recomendadas](durable-best-practices.md).
+ Saiba mais sobre como testar as funções duráveis localmente e na nuvem Consulte [Testes de funções duráveis](durable-testing.md).
+ Compare funções duráveis com o Step Functions para entender quando cada abordagem é mais eficaz. Consulte [Funções duráveis ou Step Functions](durable-step-functions.md).