# 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.
Atualmente, as funções duráveis em Java (Pré-visualização) só podem ser realizadas por meio de imagens de contêiner. Para obter mais informações sobre como criar funções duráveis a partir de imagens de contêiner, consulte [Runtimes compatíveis com funções duráveis](durable-supported-runtimes.md) ou [Implantar funções duráveis do Lambda com Infraestrutura como Código](durable-getting-started-iac.md).
**nota**
Atualmente, as funções duráveis oferecem suporte a runtimes de Python e Node.js (JavaScript/TypeScript) e imagens de contêiner (OCI), como Java. 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. Selecione **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:CheckpointDurableExecutions` 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.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/durable-nodejs.png)
1. Cole o código a seguir na guia **index.mjs**, substituindo o código que o Lambda criou.
```
import {
DurableContext,
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:
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**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\$1function.py** no editor de código, selecione **lambda\$1function.py** no explorador de arquivos, conforme mostrado no diagrama a seguir.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/durable-python.png)
1. Cole o código a seguir na guia **lambda\$1function.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:
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**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**.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/getting-started-tutorial/test-event.png)
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:
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/getting-started-tutorial/run-test-event.png)
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.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/log-stream.png)
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).
# Implemente e invoque funções duráveis do Lambda com a AWS CLI
Use a AWS CLI para criar e implantar funções duráveis do Lambda com comandos imperativos. Essa abordagem oferece controle direto sobre cada etapa do processo de implantação.
## Pré-requisitos
+ Instale e configure a . AWS CLI. Para obter instruções, consulte [Instalação da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Crie um pacote de implantação com o código de função e o SDK de execução durável.
+ Crie um perfil de execução no IAM com a permissões para pontos de verificação.
## Criar a função de execução
Crie um perfil do IAM com permissões para operações básicas de execução e ponto de verificação do Lambda.
**Para criar a função de execução**
1. Crie um documento de política de confiança que permita que o Lambda assuma o perfil. Salve-o como `trust-policy.json`:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Crie a função:
```
aws iam create-role \
--role-name durable-function-role \
--assume-role-policy-document file://trust-policy.json
```
1. Anexe a política de execução durável para operações de ponto de verificação e execução básica:
```
aws iam attach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
```
A política gerenciada `AWSLambdaBasicDurableExecutionRolePolicy` inclui as permissões necessárias para operações de ponto de verificação (`lambda:CheckpointDurableExecutions` e `lambda:GetDurableExecutionState`) e execução básica do Lambda.
## Criação da função durável
Crie sua função durável com o parâmetro `--durable-config`.
**Para criar uma função durável**
1. Empacote seu código de função com as dependências em um arquivo .zip:
```
zip -r function.zip index.mjs node_modules/
```
1. Crie a função com a execução durável habilitada:
```
aws lambda create-function \
--function-name myDurableFunction \
--runtime nodejs22.x \
--role arn:aws:iam::123456789012:role/durable-function-role \
--handler index.handler \
--zip-file fileb://function.zip \
--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'
```
**nota**
Você só pode habilitar a execução durável ao criar a função. Não é possível habilitá-la em funções existentes.
**nota**
Atualmente, funções duráveis em Java (Pré-visualização) só podem ser criadas por meio de imagens de contêiner. Para obter mais informações sobre como criar funções duráveis a partir de imagens de contêiner, consulte [Runtimes compatíveis para funções duráveis](durable-supported-runtimes.md).
## Publicação de uma versão
Embora as funções duráveis possam ser invocadas usando o qualificador de versão `$LATEST`, você sempre deve usar um ARN qualificado apontando para uma versão estável a fim de garantir a execução determinística do seu código.
```
aws lambda publish-version \
--function-name myDurableFunction \
--description "Initial version"
```
O comando retorna o ARN da versão. Anote o número da versão (por exemplo, `:1`) no final do ARN.
Opcionalmente, crie um alias que aponte para a versão.
```
aws lambda create-alias \
--function-name myDurableFunction \
--name prod \
--function-version 1
```
## Invocação da função durável
Invoque sua função durável usando o ARN qualificado (versão ou alias).
**nota**
**Invocações idempotentes:** para evitar execuções duplicadas ao tentar novamente invocações com falha, você pode especificar um nome de execução que garanta uma semântica de execução única. Consulte [Idempotência](durable-execution-idempotency.md) para obter detalhes.
**Invocação síncrona**
Para execuções concluídas dentro de 15 minutos, use a invocação síncrona:
```
aws lambda invoke \
--function-name myDurableFunction:1 \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
Ou usando um alias:
```
aws lambda invoke \
--function-name myDurableFunction:prod \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
**Invocação assíncrona**
Para execuções de longa duração, use a invocação assíncrona:
```
aws lambda invoke \
--function-name myDurableFunction:prod \
--invocation-type Event \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
Com a invocação assíncrona, o Lambda retorna imediatamente. A função continua em execução em segundo plano.
**nota**
Você pode usar `$LATEST` para prototipagem e testes no console. Para workloads de produção, use uma versão publicada ou um alias.
## Gerenciamento de execuções duráveis
Use os comandos a seguir para gerenciar e monitorar execuções de funções duráveis
**Execuções de lista**
Liste todas as execuções de uma função durável:
```
aws lambda list-durable-executions-by-function \
--function-name myDurableFunction
```
**Obtenção dos detalhes da execução**
Obtenha detalhes sobre uma execução específica:
```
aws lambda get-durable-execution \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
**Obtenção do histórico de execução**
Visualize o histórico de pontos de verificação de uma execução:
```
aws lambda get-durable-execution-history \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
**Interrupção de uma execução**
Interrompa uma execução durável em andamento:
```
aws lambda stop-durable-execution \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
## Atualizar um código de função
Atualize o código da sua função durável e publique uma nova versão:
**Para atualizar e publicar uma nova versão**
1. Atualize o código da função:
```
aws lambda update-function-code \
--function-name myDurableFunction \
--zip-file fileb://function.zip
```
1. Aguarde até que a atualização seja concluída:
```
aws lambda wait function-updated \
--function-name myDurableFunction
```
1. Publique uma nova versão:
```
aws lambda publish-version \
--function-name myDurableFunction \
--description "Updated order processing logic"
```
1. Atualize o alias para apontar para a nova versão.
```
aws lambda update-alias \
--function-name myDurableFunction \
--name prod \
--function-version 2
```
**Importante**
As execuções em andamento continuam usando a versão com a qual foram iniciadas. Novas invocações usarão a versão atualizada do alias.
## Visualizar logs de função
Visualize os logs da sua função durável no CloudWatch Logs:
```
aws logs tail /aws/lambda/myDurableFunction --follow
```
Filtre logs para uma execução específica:
```
aws logs filter-log-events \
--log-group-name /aws/lambda/myDurableFunction \
--filter-pattern "exec-abc123"
```
## Limpar os recursos
Exclua sua função durável e os recursos associados:
```
# Delete the function
aws lambda delete-function --function-name myDurableFunction
# Delete the IAM role policies
aws iam detach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam detach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
# Delete the role
aws iam delete-role --role-name durable-function-role
```
## Próximas etapas
Depois de implantar sua função durável com a AWS CLI:
+ Monitore as execuções usando os comandos `list-durable-executions` e `get-durable-execution`
+ Visualize as operações de ponto de verificação em eventos de dados do AWS CloudTrail
+ Configure os alarmes do CloudWatch para falhas de execução ou execuções de longa duração
+ Automatize as implantações usando scripts de shell ou pipelines de CI/CD
Para obter mais informações sobre os comandos da AWS CLI para o Lambda, consulte a [Referência de comandos da AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/lambda/index.html).
# Implemente funções duráveis do Lambda com infraestrutura como código
É possível implantar funções duráveis do Lambda usando ferramentas de infraestrutura como código (IaC) como AWS CloudFormation, AWS CDK, AWS Serverless Application Model ou Terraform. Essas ferramentas permitem que você defina sua função, perfil de execução e permissões no código, tornando as implantações repetíveis e controladas por versão.
Todas as três ferramentas exigem que você:
+ Habilite a execução durável da função
+ Conceda permissões de ponto de verifica';cão para o perfil de execução
+ Publique uma versão ou crie um alias (funções duráveis exigem ARNs qualificados)
## Funcionalidades duradouras a partir de um ZIP
### AWS CloudFormation
Use CloudFormation para definir sua função durável em um modelo. O exemplo a seguir cria uma função durável com as permissões necessárias.
```
AWSTemplateFormatVersion: '2010-09-09'
Description: Lambda durable function example
Resources:
DurableFunctionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
DurableFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: myDurableFunction
Runtime: nodejs22.x
Handler: index.handler
Role: !GetAtt DurableFunctionRole.Arn
Code:
ZipFile: |
// Your durable function code here
export const handler = async (event, context) => {
return { statusCode: 200 };
};
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
DurableFunctionVersion:
Type: AWS::Lambda::Version
Properties:
FunctionName: !Ref DurableFunction
Description: Initial version
DurableFunctionAlias:
Type: AWS::Lambda::Alias
Properties:
FunctionName: !Ref DurableFunction
FunctionVersion: !GetAtt DurableFunctionVersion.Version
Name: prod
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunctionAlias
```
**Para implantar o modelo**
```
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-durable-function-stack \
--capabilities CAPABILITY_IAM
```
### AWS CDK
AWS CDK permite definir a infraestrutura usando linguagens de programação. Os exemplos a seguir mostram como criar uma função durável usando TypeScript e Python.
------
#### [ TypeScript ]
```
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';
export class DurableFunctionStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Create the durable function
const durableFunction = new lambda.Function(this, 'DurableFunction', {
runtime: lambda.Runtime.NODEJS_22_X,
handler: 'index.handler',
code: lambda.Code.fromAsset('lambda'),
functionName: 'myDurableFunction',
durableConfig: { executionTimeout: Duration.hours(1), retentionPeriod: Duration.days(30) },
});
// Create version and alias
const version = durableFunction.currentVersion;
const alias = new lambda.Alias(this, 'ProdAlias', {
aliasName: 'prod',
version: version,
});
// Output the alias ARN
new cdk.CfnOutput(this, 'FunctionAliasArn', {
value: alias.functionArn,
description: 'Use this ARN to invoke the durable function',
});
}
}
```
------
#### [ Python ]
```
from aws_cdk import (
Stack,
aws_lambda as lambda_,
aws_iam as iam,
CfnOutput,
)
from constructs import Construct
class DurableFunctionStack(Stack):
def __init__(self, scope: Construct, id: str, **kwargs):
super().__init__(scope, id, **kwargs)
# Create the durable function
durable_function = lambda_.Function(
self, 'DurableFunction',
runtime=lambda_.Runtime.NODEJS_22_X,
handler='index.handler',
code=lambda_.Code.from_asset('lambda'),
function_name='myDurableFunction',
durable_execution={execution_timeout: Duration.hours(1), retention_period: Duration.days(30)}
)
# Add durable execution managed policy for checkpoint permissions
durable_function.role.add_managed_policy(
iam.ManagedPolicy.from_aws_managed_policy_name('service-role/AWSLambdaBasicDurableExecutionRolePolicy')
)
# Create version and alias
version = durable_function.current_version
alias = lambda_.Alias(
self, 'ProdAlias',
alias_name='prod',
version=version
)
# Output the alias ARN
CfnOutput(
self, 'FunctionAliasArn',
value=alias.function_arn,
description='Use this ARN to invoke the durable function'
)
```
------
**Para implantar a pilha do CDK**
```
cdk deploy
```
### AWS Serverless Application Model
O AWS SAM simplifica os modelos do CloudFormation para aplicações com tecnologia sem servidor. O modelo a seguir cria uma função durável com o AWS SAM.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Lambda durable function with SAM
Resources:
DurableFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: myDurableFunction
Runtime: nodejs22.x
Handler: index.handler
CodeUri: ./src
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
Policies:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
AutoPublishAlias: prod
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunction.Alias
```
**Para implantar o modelo do SAM**
```
sam build
sam deploy --guided
```
### Terraform
O Terraform é uma ferramenta popular de IaC de código aberto que oferece suporte a recursos de AWS. O exemplo a seguir cria uma função durável com o Terraform usando a versão 6.25.0 ou posterior do provedor AWS.
```
terraform {
required_version = ">= 1.0"
required_providers {
aws = {
source = "hashicorp/aws"
version = ">= 6.25.0"
}
}
}
provider "aws" {
region = "us-east-2"
}
# IAM Role for Lambda Function
resource "aws_iam_role" "lambda_role" {
name = "durable-function-role"
assume_role_policy = jsonencode({
Version = "2012-10-17"
Statement = [{
Action = "sts:AssumeRole"
Effect = "Allow"
Principal = {
Service = "lambda.amazonaws.com"
}
}]
})
}
# Attach durable execution policy for checkpoint operations
resource "aws_iam_role_policy_attachment" "lambda_durable" {
policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy"
role = aws_iam_role.lambda_role.name
}
# Lambda Function with Durable Execution enabled
resource "aws_lambda_function" "durable_function" {
filename = "function.zip"
function_name = "myDurableFunction"
role = aws_iam_role.lambda_role.arn
handler = "index.handler"
runtime = "nodejs22.x"
timeout = 30
memory_size = 512
durable_config {
execution_timeout = 900
retention_period = 7
}
}
# Publish a version
resource "aws_lambda_alias" "prod" {
name = "prod"
function_name = aws_lambda_function.durable_function.function_name
function_version = aws_lambda_function.durable_function.version
}
output "function_arn" {
description = "ARN of the Lambda function"
value = aws_lambda_function.durable_function.arn
}
output "alias_arn" {
description = "ARN of the function alias (use this for invocations)"
value = aws_lambda_alias.prod.arn
}
```
**Para implantar com o Terraform**
```
terraform init
terraform plan
terraform apply
```
**nota**
O suporte do Terraform para funções duráveis do Lambda requer a versão 6.25.0 ou posterior do provedor AWS. Atualize a versão do seu provedor se você estiver usando uma versão mais antiga.
## Funções duráveis a partir de uma imagem de contêiner OCI
Ainda é possível criar funções Durable com base em imagens de contêiner. Para obter instruções sobre como criar uma imagem de contêiner, consulte [Runtimes compatíveis com funções duráveis](durable-supported-runtimes.md).
### AWS CDK
AWS CDK permite definir a infraestrutura usando linguagens de programação. Os exemplos a seguir mostram como criar uma função durável usando TypeScript a partir de uma imagem de contêiner.
```
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';
export class DurableFunctionStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Create the durable function
const durableFunction = new lambda.DockerImageFunction(this, 'DurableFunction', {
code: lambda.DockerImageCode.fromImageAsset('./lambda', {
platform: cdk.aws_ecr_assets.Platform.LINUX_AMD64,
}),
functionName: 'myDurableFunction',
memorySize: 512,
timeout: cdk.Duration.seconds(30),
durableConfig: { executionTimeout: cdk.Duration.hours(1), retentionPeriod: cdk.Duration.days(30) },
});
// Create version and alias
const version = durableFunction.currentVersion;
const alias = new lambda.Alias(this, 'ProdAlias', {
aliasName: 'prod',
version: version,
});
// Output the alias ARN
new cdk.CfnOutput(this, 'FunctionAliasArn', {
value: alias.functionArn,
description: 'Use this ARN to invoke the durable function',
});
}
}
```
**Para implantar a pilha do CDK**
```
cdk deploy
```
### AWS Serverless Application Model
O AWS SAM simplifica os modelos do CloudFormation para aplicações com tecnologia sem servidor. O modelo a seguir cria uma função durável com o AWS SAM.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Lambda durable function with SAM
Resources:
DurableFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: myDurableFunction
PackageType: Image
ImageUri: ./src
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
Policies:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
AutoPublishAlias: prod
Metadata:
DockerTag: latest
DockerContext: ./src
Dockerfile: Dockerfile
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunction.Alias
```
**Para implantar o modelo do SAM**
```
sam build
sam deploy --guided
```
## Padrões de configuração comuns
Independentemente de qual ferramenta de IaC você usar, siga estes padrões para funções duráveis:
**Habilitação da execução durável**
Defina a propriedade `DurableConfig` em sua função para permitir uma execução durável. Essa propriedade só estará disponível ao criar a função. Não é possível habilitar execuções duráveis em funções existentes.
**Concessão de permissões de ponto de verificação**
Anexe a política gerenciada `AWSLambdaBasicDurableExecutionRolePolicy` ao perfil de execução. Essa política inclui as permissões obrigatórias de `lambda:CheckpointDurableExecutions` e `lambda:GetDurableExecutionState`.
**Use ARNs qualificados**
Crie um uma versão ou alias para a sua função. As funções duráveis exigem ARNs qualificados (com versão ou alias) para invocação. Use `AutoPublishAlias` no AWS SAM ou crie versões explícitas no CloudFormation, AWS CDK e Terraform.
**Dependências de pacotes**
Inclua o SDK de execução durável em seu pacote de implantação. Para o Node.js, instale `@aws/durable-execution-sdk-js`. Para Python, instale `aws-durable-execution-sdk-python`.
## Próximas etapas
Depois de implantar sua função durável:
+ Teste sua função usando o ARN qualificado (versão ou alias)
+ Monitore o progresso da execução no console do Lambda, na guia Execuções duráveis
+ Visualize as operações de ponto de verificação em eventos de dados do AWS CloudTrail
+ Analise o CloudWatch Logs para analisar a saída da função e o comportamento de reprodução
Para obter mais informações sobre como implantar funções do Lambda com ferramentas de IaC, consulte:
+ [CloudFormation Referência de AWS::Lambda::Function do](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Documentação do módulo Lambda do](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM Guia do desenvolvedor do](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)