# SDK de execução durável
O SDK de execução durável é a base para a criação de funções duráveis. Ele fornece os elementos básicos de que você precisa para verificar o progresso, lidar com novas tentativas e gerenciar o fluxo de execução. O SDK abstrai a complexidade do gerenciamento e da reprodução de pontos de verificação, permitindo que você escreva um código sequencial que automaticamente se torna com tolerância a falhas.
O SDK está disponível para JavaScript, TypeScript, Python e Java (versão prévia). Para obter a documentação completa da API e exemplos, consulte o [JavaScript/TypeScript SDK](https://github.com/aws/aws-durable-execution-sdk-js), o [Python SDK](https://github.com/aws/aws-durable-execution-sdk-python) e o [Java SDK](https://github.com/aws/aws-durable-execution-sdk-java) no GitHub.
## DurableContext
O SDK fornece à sua função um objeto `DurableContext` que expõe todas as operações duráveis. Esse contexto substitui o contexto padrão do Lambda e fornece métodos para a criação de pontos de verificação, gerenciamento do fluxo de execução e coordenação com sistemas externos.
Para usar o SDK, encapsule seu manipulador Lambda com o wrapper de execução durável:
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Your function receives DurableContext instead of Lambda context
// Use context.step(), context.wait(), etc.
return result;
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
@durable_execution
def handler(event: dict, context: DurableContext):
# Your function receives DurableContext
# Use context.step(), context.wait(), etc.
return result
```
------
#### [ Java (Preview) ]
```
import software.amazon.lambda.durable.DurableContext;
import software.amazon.lambda.durable.DurableHandler;
public class Handler extends DurableHandler {
@Override
public String handleRequest(Object input, DurableContext context) {
// Your function receives DurableContext
// Use context.step(), context.wait(), etc.
return result;
}
}
```
------
O wrapper intercepta a invocação da sua função, carrega qualquer log de ponto de verificação existente e fornece o `DurableContext` que gerencia a reprodução e a criação dos pontos de verificação.
## O que o SDK faz
O SDK lida com três responsabilidades críticas que habilitam a execução durável:
**Gerenciamento de pontos de verificação:** o SDK cria pontos de verificação automaticamente à medida que sua função executa operações duráveis. Cada ponto de verificação registra o tipo de operação, as entradas e os resultados. Quando sua função conclui uma etapa, o SDK persiste no ponto de verificação antes de prosseguir. Isso garante que sua função possa ser retomada a partir de qualquer operação concluída, caso seja interrompida.
**Coordenação de reprodução:** quando sua função é retomada após uma pausa ou interrupção, o SDK executa a reprodução. Ele executa seu código desde o início, mas ignora as operações concluídas, usando resultados de pontos de verificação armazenados em vez de reexecutá-las. O SDK garante que a reprodução seja determinística, de forma que, dadas as mesmas entradas e o mesmo log do ponto de verificação, sua função produz os mesmos resultados.
**Isolamento de estado:** o SDK mantém o estado de execução separadamente da sua lógica de negócios. Cada execução durável tem seu próprio log de ponto de verificação que outras execuções não podem acessar. O SDK criptografa os dados em repouso do ponto de verificação e garante que o estado permaneça consistente em todas as reproduções.
## Como o ponto de verificação funciona
Quando você chama uma operação durável, o SDK segue esta sequência:
1. **Verificar o ponto de verificação existente:** o SDK verifica se essa operação já foi concluída em uma invocação anterior. Se existir um ponto de verificação, o SDK retornará o resultado armazenado sem reexecutar a operação.
1. **Executar a operação:** se não existir nenhum ponto de verificação, o SDK executará seu código de operação. Para etapas, isso significa chamar sua função. Para esperas, isso significa agendar a retomada.
1. **Criar ponto de verificação:** após a conclusão da operação, o SDK serializa o resultado e cria um ponto de verificação. O ponto de verificação inclui o tipo de operação, nome, entradas, resultado e timestamp.
1. **Persistir o ponto de verificação:** o SDK chama a API de ponto de verificação do Lambda para persistir o ponto de verificação. Isso garante que o ponto de verificação seja durável antes de prosseguir com a execução.
1. **Retornar resultado:** o SDK retorna o resultado da operação para seu código, que prossegue até a próxima operação.
Essa sequência garante que, após a conclusão da operação, seu resultado seja armazenado com segurança. Se sua função for interrompida em algum momento, o SDK poderá reproduzi-la até o último ponto de verificação concluído.
## Comportamento da reprodução
Quando sua função é retomada após uma pausa ou interrupção, o SDK executa a reprodução.
1. **Carregar log do ponto de verificação:** o SDK recupera o log do ponto de verificação para essa execução do Lambda.
1. **Executar desde o início:** o SDK invoca sua função de manipulador desde o início, não de onde ela foi pausada.
1. **Ignorar operações duráveis concluídas:** à medida que seu código chama operações duráveis, o SDK compara cada uma delas com base no log do ponto de verificação. Para operações duráveis concluídas, o SDK retorna o resultado armazenado sem executar o código da operação.
**nota**
Se o resultado do contexto secundário for maior que o tamanho máximo do ponto de verificação (256 KB), o código do contexto será executado novamente durante a reprodução. Isso permite que você construa grandes resultados a partir das operações duráveis executadas dentro do contexto, que serão consultadas no log do ponto de verificação. Portanto, é imperativo executar apenas código determinístico no próprio contexto. Ao usar contextos secundários com grandes resultados, é uma prática recomendada realizar trabalhos de longa duração ou não determinísticos dentro das etapas e realizar apenas tarefas de curta duração que combinem os resultados no próprio contexto.
1. **Retomar no ponto de interrupção:** quando o SDK alcança uma operação sem um ponto de verificação, ele é executado normalmente e cria novos pontos de verificação à medida que as operações duráveis são concluídas.
Esse mecanismo de reprodução exige que seu código seja determinístico. Com as mesmas entradas e o mesmo log do ponto de verificação, sua função deve fazer a mesma sequência de chamadas de operação duráveis. O SDK aplica isso validando se os nomes e tipos de operação correspondem ao log do ponto de verificação durante a reprodução.
## Operações duráveis disponíveis
O `DurableContext` fornece operações para diferentes padrões de coordenação. Cada operação durável cria pontos de verificação automaticamente, garantindo que sua função possa ser retomada a partir de qualquer ponto.
### Etapas
Executa a lógica de negócios com verificação automática e nova tentativa. Use etapas para operações que chamem serviços externos, realizem cálculos ou executem qualquer lógica que deva ser verificada. O SDK cria um ponto de verificação antes e depois da etapa, armazenando o resultado para reprodução.
------
#### [ TypeScript ]
```
const result = await context.step('process-payment', async () => {
return await paymentService.charge(amount);
});
```
------
#### [ Python ]
```
result = context.step(
lambda _: payment_service.charge(amount),
name='process-payment'
)
```
------
#### [ Java (Preview) ]
```
var result = context.step("process-payment", Payment.class,
() -> paymentService.charge(amount)
);
```
------
As etapas oferecem suporte a estratégias de reprodução configuráveis, semântica de execução (no máximo uma vez ou pelo menos uma vez) e serialização personalizada.
### Espera
Pausa a execução por um período especificado sem consumir recursos computacionais. O SDK cria um ponto de verificação, encerra a invocação da função e agenda a retomada. Quando a espera é concluída, o Lambda invoca sua função novamente e o SDK faz a reprodução até o ponto de espera antes de prosseguir.
------
#### [ TypeScript ]
```
// Wait 1 hour without charges
await context.wait({ seconds: 3600 });
```
------
#### [ Python ]
```
# Wait 1 hour without charges
context.wait(3600)
```
------
#### [ Java (Preview) ]
```
// Wait 1 hour without charges
context.wait(Duration.ofHours(1));
```
------
### Retornos de chamada
Os retornos de chamadas permitem que sua função faça uma pausa e aguarde até que sistemas externos forneçam entrada. Quando você cria um retorno de chamada, o SDK gera um ID de retorno de chamada exclusivo e cria um ponto de verificação. Em seguida, sua função é suspensa (encerra a invocação) sem incorrer em cobranças computacionais. Sistemas externos enviam resultados de retorno de chamada usando as APIs `SendDurableExecutionCallbackSuccess` ou `SendDurableExecutionCallbackFailure` do Lambda. Quando um retorno de chamada é enviado, o Lambda invoca sua função novamente, o SDK faz a reprodução até o ponto de retorno de chamada e sua função prossegue com o resultado do retorno de chamada.
O SDK fornece dois métodos para o trabalho com retornos de chamadas:
**createCallback:** cria um retorno de chamada e retorna uma promessa e um ID de retorno de chamada. Você envia o ID de retorno de chamada para um sistema externo, que envia o resultado usando a API do Lambda.
------
#### [ TypeScript ]
```
const [promise, callbackId] = await context.createCallback('approval', {
timeout: { hours: 24 }
});
await sendApprovalRequest(callbackId, requestData);
const approval = await promise;
```
------
#### [ Python ]
```
callback = context.create_callback(
name='approval',
config=CallbackConfig(timeout_seconds=86400)
)
context.step(
lambda _: send_approval_request(callback.callback_id),
name='send_request'
)
approval = callback.result()
```
------
#### [ Java (Preview) ]
```
var config = CallbackConfig.builder(Duration.ofHours(24)).timeout()
var callback = context.createCallback("approval", String.class, config);
context.step("send-request", String.class, () -> {
notificationService.sendApprovalRequest(callback.callbackId(), requestData);
return "request-sent";
});
// Blocks until the callback finishes or times out
String approval = callback.get();
```
------
**waitForCallback:** simplifica o tratamento do retorno de chamada combinando a criação e o envio de retornos de chamada em uma única operação. O SDK cria o retorno de chamada, executa sua função de envio com o ID de retorno de chamada e aguarda pelo resultado.
------
#### [ TypeScript ]
```
const result = await context.waitForCallback(
'external-api',
async (callbackId, ctx) => {
await submitToExternalAPI(callbackId, requestData);
},
{ timeout: { minutes: 30 } }
);
```
------
#### [ Python ]
```
result = context.wait_for_callback(
lambda callback_id: submit_to_external_api(callback_id, request_data),
name='external-api',
config=WaitForCallbackConfig(timeout_seconds=1800)
)
```
------
#### [ Java (Preview) ]
O waitForCallback ainda está em desenvolvimento para Java.
------
Configure os tempos limite para evitar que as funções esperem indefinidamente. Se um retorno de chamada atingir o tempo limite, o SDK lançará um `CallbackError` e sua função poderá tratar o caso de tempo limite. Use tempos limite de pulsação para retornos de chamada de longa duração para detectar quando os sistemas externos param de responder.
Use retornos de chamada para fluxos de trabalho com humanos no loop, integração de sistemas externos, respostas de webhook ou qualquer cenário em que a execução deva ser pausada para entradas externas.
### Execução paralela
Execute várias operações simultaneamente com o controle de simultaneidade opcional. O SDK gerencia a execução paralela, cria pontos de verificação para cada operação e trata as falhas de acordo com sua política de conclusão.
------
#### [ TypeScript ]
```
const results = await context.parallel([
async (ctx) => ctx.step('task1', async () => processTask1()),
async (ctx) => ctx.step('task2', async () => processTask2()),
async (ctx) => ctx.step('task3', async () => processTask3())
]);
```
------
#### [ Python ]
```
results = context.parallel(
lambda ctx: ctx.step(lambda _: process_task1(), name='task1'),
lambda ctx: ctx.step(lambda _: process_task2(), name='task2'),
lambda ctx: ctx.step(lambda _: process_task3(), name='task3')
)
```
------
#### [ Java (Preview) ]
O Parallel ainda está em desenvolvimento para Java.
------
Use `parallel` para executar operações independentes simultaneamente.
### Mapa
Execute simultaneamente uma operação em cada item em uma matriz com controle de simultaneidade opcional. O SDK gerencia a execução simultânea, cria pontos de verificação para cada operação e trata as falhas de acordo com sua política de conclusão.
------
#### [ TypeScript ]
```
const results = await context.map(itemArray, async (ctx, item, index) =>
ctx.step('task', async () => processItem(item, index))
);
```
------
#### [ Python ]
```
results = context.map(
item_array,
lambda ctx, item, index: ctx.step(
lambda _: process_item(item, index),
name='task'
)
)
```
------
#### [ Java (Preview) ]
O Map ainda está em desenvolvimento para Java.
------
Use `map` para processar matrizes com controle de simultaneidade.
### Contextos secundários
Cria um contexto de execução isolado para operações de agrupamento. Os contextos secundários têm seu próprio log de pontos de verificação e podem conter várias etapas, esperas e outras operações. O SDK trata todo o contexto secundário como uma única unidade para novas tentativas e recuperações.
Use contextos secundários para organizar fluxos de trabalho complexos, implementar subfluxos de trabalho ou isolar operações que devem ser tentadas novamente juntas.
------
#### [ TypeScript ]
```
const result = await context.runInChildContext(
'batch-processing',
async (childCtx) => {
return await processBatch(childCtx, items);
}
);
```
------
#### [ Python ]
```
result = context.run_in_child_context(
lambda child_ctx: process_batch(child_ctx, items),
name='batch-processing'
)
```
------
#### [ Java (Preview) ]
```
var result = context.runInChildContext(
"batch-processing",
String.class,
childCtx -> process_batch(childCtx, items)
);
```
------
O mecanismo de reprodução exige que operações duráveis ocorram em uma ordem determinística. Usando vários contextos secundários, é possível ter vários fluxos de trabalho executados simultaneamente, e o determinismo se aplica separadamente em cada contexto. Isso permite que você crie funções de alta performance que utilizem com eficiência vários núcleos de CPU.
Por exemplo, imagine que iniciamos dois contextos secundários, A e B. Na invocação inicial, as etapas dentro dos contextos foram executadas nessa ordem, com as etapas 'A' sendo executadas simultaneamente com as etapas 'B': A1, B1, B2, A2, A3. Na reprodução, o tempo é muito mais rápido, pois os resultados são recuperados do log do ponto de verificação e as etapas são encontradas em uma ordem diferente: B1, A1, A2, B2, A3. Como as etapas 'A' foram encontradas na ordem correta (A1, A2, A3) e as etapas 'B' foram encontradas na ordem correta (B1, B2), a necessidade de determinismo foi satisfeita corretamente.
### Esperas condicionais
Sondagens para uma condição com verificação automática entre as tentativas. O SDK executa sua função de verificação, cria um ponto de verificação com o resultado, espera de acordo com sua estratégia e repete até que a condição seja atendida.
------
#### [ TypeScript ]
```
const result = await context.waitForCondition(
async (state, ctx) => {
const status = await checkJobStatus(state.jobId);
return { ...state, status };
},
{
initialState: { jobId: 'job-123', status: 'pending' },
waitStrategy: (state) =>
state.status === 'completed'
? { shouldContinue: false }
: { shouldContinue: true, delay: { seconds: 30 } }
}
);
```
------
#### [ Python ]
```
result = context.wait_for_condition(
lambda state, ctx: check_job_status(state['jobId']),
config=WaitForConditionConfig(
initial_state={'jobId': 'job-123', 'status': 'pending'},
wait_strategy=lambda state, attempt:
{'should_continue': False} if state['status'] == 'completed'
else {'should_continue': True, 'delay': 30}
)
)
```
------
#### [ Java (Preview) ]
O waitForCondition ainda está em desenvolvimento para Java.
------
Use `waitForCondition` para sondar sistemas externos, esperar que os recursos estejam prontos ou implementar novas tentativas com recuo.
### invocação de funções
Invoca uma outra função do Lambda e aguarda seu resultado. O SDK cria um ponto de verificação, invoca a função de destino e retoma sua função quando a invocação é concluída. Isso permite a composição da função e a decomposição do fluxo de trabalho.
------
#### [ TypeScript ]
```
const result = await context.invoke(
'invoke-processor',
'arn:aws:lambda:us-east-1:123456789012:function:processor:1',
{ data: inputData }
);
```
------
#### [ Python ]
```
result = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:processor:1',
{'data': input_data},
name='invoke-processor'
)
```
------
#### [ Java (Preview) ]
```
var result = context.invoke(
"invoke-processor",
"arn:aws:lambda:us-east-1:123456789012:function:processor:1",
inputData,
Result.class,
InvokeConfig.builder().build()
);
```
------
## Como as operações duráveis são medidas
Cada operação durável que você executa por `DurableContext` cria pontos de verificação para monitorar o progresso da execução e armazenar dados de estado. Essas operações incorrem em cobranças com base em seu uso, e os pontos de verificação podem conter dados que contribuam para seus custos de gravação e retenção de dados. Os dados armazenados incluem dados de eventos de invocação, cargas úteis retornadas das etapas e dados transmitidos ao concluir retornos de chamada. Entender como as operações duráveis são medidas ajuda você a estimar os custos de execução e a otimizar seus fluxos de trabalho. Para obter detalhes de preços, consulte a [página de dfinição de preços do Lambda](https://aws.amazon.com/lambda/pricing/).
O tamanho da carga útil se refere ao tamanho dos dados serializados em que uma operação durável persiste. Os dados são medidos em bytes e o tamanho pode variar dependendo do serializador usado pela operação. A carga útil de uma operação pode ser o resultado em si de uma conclusão com êxito ou o objeto de erro serializado se a operação falhar.
### Operações básicas
As operações básicas são os blocos de construção fundamentais para funções duráveis:
| Operation | Tempo do ponto de verificação | Número de operações | Dados persistidos |
| --- | --- | --- | --- |
| Execução | Started | 1 | Tamanho da carga útil da entrada |
| Execução | Concluído (Com êxito/Falhado/Interrompido) | 0 | Tamanho da carga útil da saída |
| N.º da etapa | Tentativa nova/Com êxito/Falhado | 1 \$1 N novas tentativas | Tamanho da carga útil retornado de cada tentativa |
| Aguardar | Started | 1 | N/D |
| WaitForCondition | Cada tentativa de sondagem | 1 \$1 N sondagens | Tamanho da carga útil retornado de cada tentativa de sondagem |
| Nova tentativa em nível de invocação | Started | 1 | Carga útil para objeto de erro |
### Operações de retorno de chamada
Os retornos de retorno de chamada permitem que sua função faça uma pausa e aguarde até que sistemas externos forneçam entrada. Essas operações criam pontos de verificação quando o retorno de chamada é criado e quando é concluído:
| Operation | Tempo do ponto de verificação | Número de operações | Dados persistidos |
| --- | --- | --- | --- |
| CreateCallback | Started | 1 | N/D |
| Conclusão do retorno de chamada por meio de chamada de API | Completed | 0 | Carga útil de retorno de chamada |
| WaitForCallback | Started | 3 \$1 N novas tentativas (contexto \$1 retorno de chamada \$1 etapa) | Cargas retornadas pelas tentativas de etapa do remetente, mais duas cópias da carga útil de retorno de chamada |
### Operações compostas
As operações compostas combinam várias operações duráveis para lidar com padrões complexos de coordenação, como execução paralela, processamento de matrizes e contextos aninhados:
| Operation | Tempo do ponto de verificação | Número de operações | Dados persistidos |
| --- | --- | --- | --- |
| Paralelo | Started | 1 \$1 N ramificações (1 contexto primário \$1 N contextos secundários) | Até duas cópias do tamanho da carga útil retornada de cada ramificação, mais os status de cada ramificação |
| mapa | Started | 1 \$1 N ramificações (1 contexto primário \$1 N contextos secundários) | Até duas cópias do tamanho da carga útil retornada de cada iteração, mais os status de cada iteração |
| Ajudantes de promessas | Completed | 1 | Tamanho da carga útil retornado da promessa |
| RunInChildContext | Com êxito/Falhado | 1 | Tamanho da carga útil retornado do contexto secundário |
Para contextos, como de `runInChildContext` ou usados internamente por operações compostas, resultados menores que 256 KB são verificados diretamente. Resultados maiores não são armazenados. Em vez disso, eles são reconstruídos durante a reprodução por meio do reprocessamento das operações do contexto.
# Runtimes com suporte para funções duráveis
As funções duráveis estão disponíveis para determinados ambientes de runtime gerenciados e imagens de contêineres OCI, proporcionando maior flexibilidade quanto às versões de runtime. É possível criar funções duráveis para Node.js e Python utilizando runtimes gerenciados diretamente no console ou programaticamente por meio da infraestrutura como código. Atualmente, as funções duráveis em Java (Pré-visualização) só podem ser realizadas por meio de imagens de contêiner.
## Runtimes gerenciados pelo Lambda
Os runtimes gerenciados a seguir oferecem suporte a funções duráveis quando você cria funções no console do Lambda ou usa a AWS CLI com o parâmetro `--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'`. Para obter informações completas sobre os runtimes do Lambda, consulte [Runtimes do Lambda](lambda-runtimes.md).
| Linguagem | Runtime |
| --- | --- |
| Node.js | nodejs22.x |
| Node.js | nodejs24.x |
| Python | python3.13 |
| Python | python3.14 |
**nota**
Os runtimes do Lambda incluem o SDK de execução durável para testes e desenvolvimento. 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 runtimes que possam afetar o comportamento da sua função.
### Node.js
Instale o SDK no seu projeto de Node.js:
```
npm install @aws/durable-execution-sdk-js
```
O SDK oferece suporte a JavaScript e a TypeScript. Para projetos de TypeScript, o SDK inclui definições de tipo.
### Python
Instale o SDK no seu projeto de Python:
```
pip install aws-durable-execution-sdk-python
```
O SDK do Python usa métodos síncronos e não exige `async/await`.
### Java (Pré-visualização)
Adicione uma dependência a `pom.xml`:
```
software.amazon.lambda.durable
aws-durable-execution-sdk-java
VERSION
```
Instale o SDK no seu projeto Java:
```
mvn install
```
Está disponível uma versão de pré-visualização do Java SDK. As operações waitForCondition, waitForCallback, parallel e map ainda estão em desenvolvimento.
## Imagens de contêiner
É possível usar funções duráveis com imagens de contêiner para oferecer suporte a versões adicionais de runtimes ou configurações personalizadas de runtimes. As imagens de contêiner permitem que você use versões de runtimes não disponíveis como runtimes gerenciados ou personalize seu ambiente de runtime.
Para criar uma função durável usando uma imagem de contêiner:
1. Crie um Dockerfile baseado em uma imagem básica do Lambda
1. Instale o SDK de execução durável em seu contêiner
1. Crie e envie a imagem do contêiner para o Amazon Elastic Container Registry
1. Crie a função do Lambda a partir da imagem do contêiner com a execução durável habilitada
### Exemplo de contêiner
Crie um Dockerfile:
------
#### [ Python ]
Crie um Dockerfile para Python 3.11:
```
FROM public.ecr.aws/lambda/python:3.11
# Copy requirements file
COPY requirements.txt ${LAMBDA_TASK_ROOT}/
# Install dependencies including durable SDK
RUN pip install -r requirements.txt
# Copy function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}/
# Set the handler
CMD [ "lambda_function.handler" ]
```
Crie um arquivo `requirements.txt`:
```
aws-durable-execution-sdk-python
```
------
#### [ Java (Preview) ]
Crie um Dockerfile para Java 25:
```
FROM --platform=linux/amd64 public.ecr.aws/lambda/java:25
# Install Maven
RUN dnf install -y maven
WORKDIR /var/task
# Copy Maven configuration and source code
COPY pom.xml .
COPY src ./src
# Build
RUN mvn clean package -DskipTests
# Move JAR to lib directory
RUN mv target/*.jar lib/
# Set the handler
CMD ["src.path.to.lambdaFunction::handler"]
```
------
Crie e envie a imagem:
```
# Build the image
docker build -t my-durable-function .
# Tag for ECR
docker tag my-durable-function:latest 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-durable-function:latest
# Push to ECR
docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-durable-function:latest
```
Crie a função com a execução durável habilitada:
```
aws lambda create-function \
--function-name myDurableFunction \
--package-type Image \
--code ImageUri=123456789012.dkr.ecr.us-east-1.amazonaws.com/my-durable-function:latest \
--role arn:aws:iam::123456789012:role/lambda-execution-role \
--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'
```
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.
## Considerações sobre runtime
**Gerenciamento de versão do SDK:** inclua o SDK de execução durável em seu pacote de implantação ou imagem de contêiner. Isso garantirá que sua função use uma versão específica do SDK e não seja afetada pelas atualizações de runtimes. Fixe as versões do SDK no seu `package.json` ou `requirements.txt` para controlar quando você fizer o upgrade.
**Atualizações de runtimes:** AWS atualiza os runtimes gerenciados para incluir patches de segurança e correções de erros. Essas atualizações podem incluir novas versões do SDK. Para evitar comportamentos inesperados, inclua o SDK em seu pacote de implantação e teste minuciosamente antes de implantá-lo na produção.
**Tamanho da imagem do contêiner:** as imagens de contêiner têm um tamanho máximo não compactado de 10 GB. O SDK de execução durável adiciona um tamanho mínimo à sua imagem. Otimize seu contêiner usando compilações de vários estágios e removendo dependências desnecessárias.
**Performance de inicialização a frio:** as imagens de contêiner podem ter tempos de inicialização a frio mais longos do que os runtimes gerenciados. O SDK de execução durável tem um impacto mínimo na performance da inicialização a frio. Use a simultaneidade provisionada se a latência da inicialização a frio for essencial para sua aplicação.