

# Implemente e invoque funções duráveis do Lambda com a AWS CLI
<a name="durable-getting-started-cli"></a>

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
<a name="durable-cli-prerequisites"></a>
+ 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
<a name="durable-cli-create-role"></a>

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:CheckpointDurableExecution` e `lambda:GetDurableExecutionState`) e execução básica do Lambda.

## Criação da função durável
<a name="durable-cli-create-function"></a>

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/
   ```
**nota**  
Para funções duráveis baseadas em Java, você precisa compilar o código e as dependências da sua função em um único arquivo .zip ou Java Archive (JAR). Para ter mais informações, consulte [Implantar funções do Lambda em Java com arquivos .zip ou JAR](java-package.md).

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.

## Publicação de uma versão
<a name="durable-cli-publish-version"></a>

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
<a name="durable-cli-invoke"></a>

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
<a name="durable-cli-manage-executions"></a>

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
<a name="durable-cli-update-function"></a>

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
<a name="durable-cli-view-logs"></a>

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
<a name="durable-cli-cleanup"></a>

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
<a name="durable-cli-next-steps"></a>

Depois de implantar sua função durável com a AWS CLI:
+ Monitore as execuções usando os comandos `list-durable-executions-by-function` 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).