Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# SDK di esecuzione durevole
L'SDK di esecuzione durevole è la base per la creazione di funzioni durevoli. Fornisce le primitive necessarie per controllare i progressi, gestire i nuovi tentativi e gestire il flusso di esecuzione. L'SDK elimina la complessità della gestione e della riproduzione dei checkpoint, consentendoti di scrivere codice sequenziale che diventa automaticamente tollerante ai guasti.
L'SDK è disponibile per JavaScript Python e Java (anteprima). TypeScript Per la documentazione completa e gli esempi relativi alle API, consulta [JavaScript/TypeScript SDK](https://github.com/aws/aws-durable-execution-sdk-js), [Python SDK [e](https://github.com/aws/aws-durable-execution-sdk-java) Java](https://github.com/aws/aws-durable-execution-sdk-python) SDK on. GitHub
## DurableContext
L'SDK fornisce alla funzione un `DurableContext` oggetto che espone tutte le operazioni durevoli. Questo contesto sostituisce il contesto Lambda standard e fornisce metodi per creare checkpoint, gestire il flusso di esecuzione e coordinarsi con sistemi esterni.
Per utilizzare l'SDK, avvolgi il tuo gestore Lambda con il wrapper di esecuzione durevole:
------
#### [ 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;
}
}
```
------
Il wrapper intercetta l'invocazione della funzione, carica qualsiasi registro di checkpoint esistente e fornisce il file che gestisce la riproduzione e il checkpoint. `DurableContext`
## Cosa fa l'SDK
L'SDK gestisce tre responsabilità fondamentali che consentono un'esecuzione duratura:
**Gestione dei checkpoint:** l'SDK crea automaticamente i checkpoint man mano che la funzione esegue operazioni durevoli. Ogni checkpoint registra il tipo di operazione, gli input e i risultati. Quando la funzione completa un passaggio, l'SDK mantiene il checkpoint prima di continuare. Ciò garantisce che la funzione possa riprendere dopo qualsiasi operazione completata in caso di interruzione.
**Coordinamento della riproduzione:** quando la funzione riprende dopo una pausa o un'interruzione, l'SDK esegue la riproduzione. Esegue il codice dall'inizio ma salta le operazioni completate, utilizzando i risultati dei checkpoint memorizzati invece di rieseguirli. L'SDK garantisce che la riproduzione sia deterministica: con gli stessi input e lo stesso registro dei checkpoint, la funzione produce gli stessi risultati.
**Isolamento dello stato: l'**SDK mantiene lo stato di esecuzione separatamente dalla logica aziendale. Ogni esecuzione durevole ha il proprio registro dei checkpoint a cui le altre esecuzioni non possono accedere. L'SDK crittografa i dati dei checkpoint inattivi e garantisce che lo stato rimanga coerente tra i replay.
## Come funziona il checkpoint
Quando si chiama un'operazione duratura, l'SDK segue questa sequenza:
1. **Verifica la presenza di un checkpoint esistente:** l'SDK verifica se questa operazione è già stata completata in una precedente chiamata. Se esiste un checkpoint, l'SDK restituisce il risultato memorizzato senza rieseguire l'operazione.
1. **Esegui l'operazione:** se non esiste alcun checkpoint, l'SDK esegue il codice operativo. Per quanto riguarda i passaggi, ciò significa chiamare la funzione. Per le attese, ciò significa la ripresa della pianificazione.
1. **Crea checkpoint:** una volta completata l'operazione, l'SDK serializza il risultato e crea un checkpoint. Il checkpoint include il tipo di operazione, il nome, gli input, il risultato e il timestamp.
1. **Checkpoint persistente:** l'SDK chiama l'API checkpoint Lambda per rendere persistente il checkpoint. Ciò garantisce che il checkpoint sia duraturo prima di continuare l'esecuzione.
1. **Risultato di ritorno:** l'SDK restituisce il risultato dell'operazione al codice, che continua con l'operazione successiva.
Questa sequenza assicura che, una volta completata un'operazione, il risultato venga archiviato in modo sicuro. Se la funzione viene interrotta in qualsiasi momento, l'SDK può riprodurla fino all'ultimo checkpoint completato.
## Comportamento di riproduzione
Quando la funzione riprende dopo una pausa o un'interruzione, l'SDK esegue la riproduzione:
1. **Carica il registro del checkpoint:** l'SDK recupera il registro dei checkpoint per questa esecuzione da Lambda.
1. **Esegui dall'inizio:** l'SDK richiama la funzione di gestione dall'inizio, non dal punto in cui è stata messa in pausa.
1. **Ignora le operazioni durevoli completate:** man mano che il codice richiama operazioni durevoli, l'SDK confronta ciascuna di esse con il registro del checkpoint. Per operazioni durevoli completate, l'SDK restituisce il risultato memorizzato senza eseguire il codice operativo.
**Nota**
Se il risultato di un contesto secondario era maggiore della dimensione massima del checkpoint (256 KB), il codice del contesto viene eseguito nuovamente durante la riproduzione. Ciò consente di ottenere risultati di grandi dimensioni a partire dalle operazioni durevoli eseguite all'interno del contesto, che verranno ricercate dal registro del checkpoint. Pertanto è imperativo eseguire codice deterministico solo nel contesto stesso. Quando si utilizzano contesti secondari con risultati di grandi dimensioni, è consigliabile eseguire un lavoro di lunga durata o non deterministico all'interno di passaggi ed eseguire solo attività di breve durata che combinano i risultati nel contesto stesso.
1. **Riprendi al punto di interruzione: quando l'SDK raggiunge un'operazione senza checkpoint**, viene eseguita normalmente e crea nuovi checkpoint man mano che le operazioni durevoli vengono completate.
Questo meccanismo di replay richiede che il codice sia deterministico. Con gli stessi input e lo stesso registro dei checkpoint, la funzione deve effettuare la stessa sequenza di chiamate operative durevoli. L'SDK lo impone convalidando che i nomi e i tipi di operazioni corrispondano al registro del checkpoint durante la riproduzione.
## Operazioni durevoli disponibili
`DurableContext`Fornisce operazioni per diversi modelli di coordinamento. Ogni operazione durevole crea automaticamente dei checkpoint, assicurando che la funzione possa riprendere da qualsiasi punto.
### Fasi
Esegue la logica aziendale con checkpoint e nuovi tentativi automatici. Utilizza i passaggi per le operazioni che richiamano servizi esterni, eseguono calcoli o eseguono qualsiasi logica che dovrebbe essere sottoposta a checkpoint. L'SDK crea un checkpoint prima e dopo il passaggio, memorizzando il risultato per la riproduzione.
------
#### [ 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)
);
```
------
I passaggi supportano strategie di ripetizione configurabili, semantica di esecuzione (at-most-once or) e serializzazione personalizzata. at-least-once
### Stati di attesa
Sospende l'esecuzione per una durata specificata senza consumare risorse di elaborazione. L'SDK crea un checkpoint, termina l'invocazione della funzione e pianifica la ripresa. Al termine dell'attesa, Lambda richiama nuovamente la funzione e l'SDK viene riprodotto fino al punto di attesa prima di continuare.
------
#### [ 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));
```
------
### Callback
I callback consentono alla funzione di mettere in pausa e attendere che sistemi esterni forniscano input. Quando si crea un callback, l'SDK genera un ID di callback univoco e crea un checkpoint. La funzione viene quindi sospesa (termina la chiamata) senza incorrere in costi di calcolo. I sistemi esterni inviano i risultati del callback utilizzando `SendDurableExecutionCallbackSuccess` o `SendDurableExecutionCallbackFailure` Lambda APIs. Quando viene inviata una callback, Lambda richiama nuovamente la funzione, l'SDK viene riprodotto fino al punto di callback e la funzione continua con il risultato del callback.
L'SDK fornisce due metodi per lavorare con i callback:
**CreateCallback:** crea un callback e restituisce sia una promessa che un ID di callback. L'ID di callback viene inviato a un sistema esterno, che invia il risultato utilizzando l'API 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:** semplifica la gestione delle callback combinando la creazione e l'invio delle callback in un'unica operazione. L'SDK crea il callback, esegue la funzione di invio con l'ID di callback e attende il risultato.
------
#### [ 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) ]
waitForCallback è ancora in fase di sviluppo per Java.
------
Configura i timeout per evitare che le funzioni restino in attesa a tempo indeterminato. Se scade un callback, l'SDK genera un timeout `CallbackError` e la tua funzione può gestire il caso di timeout. Utilizza i timeout del battito cardiaco per le richiamate di lunga durata per rilevare quando i sistemi esterni smettono di rispondere.
Utilizza i callback per human-in-the-loop flussi di lavoro, integrazione di sistemi esterni, risposte webhook o qualsiasi scenario in cui l'esecuzione debba essere messa in pausa per l'input esterno.
### Esecuzione parallela
Esegue più operazioni contemporaneamente con il controllo della concorrenza opzionale. L'SDK gestisce l'esecuzione parallela, crea checkpoint per ogni operazione e gestisce gli errori in base alla politica di completamento.
------
#### [ 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) ]
Parallel è ancora in fase di sviluppo per Java.
------
`parallel`Utilizzato per eseguire operazioni indipendenti contemporaneamente.
### Eseguire la mappatura
Esegue contemporaneamente un'operazione su ogni elemento di una matrice con controllo di concorrenza opzionale. L'SDK gestisce l'esecuzione simultanea, crea checkpoint per ogni operazione e gestisce gli errori in base alla politica di completamento.
------
#### [ 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) ]
Map è ancora in fase di sviluppo per Java.
------
`map`Utilizzato per elaborare array con controllo di concorrenza.
### Contesti infantili
Crea un contesto di esecuzione isolato per le operazioni di raggruppamento. I contesti secondari dispongono di un proprio registro dei checkpoint e possono contenere più passaggi, attese e altre operazioni. L'SDK tratta l'intero contesto secondario come una singola unità per riprovare e ripristinare.
Utilizza i contesti secondari per organizzare flussi di lavoro complessi, implementare flussi di lavoro secondari o isolare operazioni da riprovare contemporaneamente.
------
#### [ 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)
);
```
------
Il meccanismo di replay richiede che le operazioni durevoli avvengano in un ordine deterministico. Utilizzando più contesti secondari è possibile eseguire contemporaneamente più flussi di lavoro e il determinismo si applica separatamente all'interno di ciascun contesto. Ciò consente di creare funzioni ad alte prestazioni che utilizzano in modo efficiente più core della CPU.
Ad esempio, immaginiamo di iniziare due contesti secondari, A e B. Nella chiamata iniziale, i passaggi all'interno dei contesti sono stati eseguiti in questo ordine, con i passaggi «A» eseguiti contemporaneamente ai passaggi «B»: A1, B1, B2, A2, A3. Dopo la riproduzione, i tempi sono molto più rapidi in quanto i risultati vengono recuperati dal registro dei checkpoint e i passaggi vengono eseguiti in un ordine diverso: B1, A1, A2, B2, A3. Poiché i passaggi «A» sono stati rilevati nell'ordine corretto (A1, A2, A3) e i passaggi «B» sono stati rilevati nell'ordine corretto (B1, B2), l'esigenza del determinismo è stata soddisfatta correttamente.
### Attese condizionali
Sondaggi relativi a una condizione con checkpoint automatico tra un tentativo e l'altro. L'SDK esegue la funzione di controllo, crea un checkpoint con il risultato, attende in base alla strategia scelta e ripete l'operazione finché la condizione non viene soddisfatta.
------
#### [ 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) ]
waitForCondition è ancora in fase di sviluppo per Java.
------
`waitForCondition`Utilizzatelo per eseguire il polling di sistemi esterni, attendere che le risorse siano pronte o implementare nuovi tentativi con backoff.
### Invocazione della funzione
Richiama un'altra funzione Lambda e ne attende il risultato. L'SDK crea un checkpoint, richiama la funzione di destinazione e riprende la funzione al termine della chiamata. Ciò consente la composizione delle funzioni e la scomposizione del flusso di lavoro.
------
#### [ 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()
);
```
------
## Come viene misurata la durata delle operazioni
Ogni operazione duratura eseguita `DurableContext` crea punti di controllo per tenere traccia dell'avanzamento dell'esecuzione e archiviare i dati sullo stato. Queste operazioni comportano addebiti in base al loro utilizzo e i checkpoint possono contenere dati che contribuiscono ai costi di scrittura e conservazione dei dati. I dati archiviati includono i dati degli eventi di invocazione, i payload restituiti dai passaggi e i dati trasmessi durante il completamento dei callback. Comprendere come viene misurata la durata delle operazioni consente di stimare i costi di esecuzione e ottimizzare i flussi di lavoro. Per i dettagli sui prezzi, consulta la pagina dei [prezzi di Lambda](https://aws.amazon.com/lambda/pricing/).
La dimensione del payload si riferisce alla dimensione dei dati serializzati necessari a garantire la persistenza di un'operazione durevole. I dati vengono misurati in byte e la dimensione può variare a seconda del serializzatore utilizzato dall'operazione. Il payload di un'operazione potrebbe essere il risultato stesso del completamento con successo o l'oggetto di errore serializzato se l'operazione non è riuscita.
### Operazioni di base
Le operazioni di base sono gli elementi costitutivi fondamentali per funzioni durevoli:
| Operation | Tempistica dei checkpoint | Numero di operazioni | Dati persistenti |
| --- | --- | --- | --- |
| Esecuzione | Avviato | 1 | Dimensione del payload di input |
| Esecuzione | Completato () Succeeded/Failed/Stopped | 0 | Dimensione del payload in uscita |
| Fase | Retry/Succeeded/Failed | 1 \$1 Nessun tentativo | Dimensione del payload restituita da ogni tentativo |
| Attendi | Avviato | 1 | N/D |
| WaitForCondition | Ogni tentativo di sondaggio | 1 \$1 N sondaggi | Dimensione del payload restituita da ogni tentativo di sondaggio |
| Riprova a livello di chiamata | Avviato | 1 | Payload per l'oggetto di errore |
### Operazioni di callback
Le operazioni di callback consentono alla funzione di mettere in pausa e attendere che sistemi esterni forniscano input. Queste operazioni creano punti di controllo quando il callback viene creato e quando è completato:
| Operation | Tempistica del checkpoint | Numero di operazioni | Dati persistenti |
| --- | --- | --- | --- |
| CreateCallback | Avviato | 1 | N/D |
| Completamento del callback tramite chiamata API | Completato | 0 | Payload di callback |
| WaitForCallback | Avviato | 3\$1 N tentativi (contesto \$1 callback \$1 step) | Payload restituiti dai tentativi di invio, più due copie del payload di callback |
### Operazioni composte
Le operazioni composte combinano più operazioni durevoli per gestire modelli di coordinamento complessi come esecuzione parallela, elaborazione di array e contesti annidati:
| Operation | tempistica dei checkpoint | Numero di operazioni | Dati persistenti |
| --- | --- | --- | --- |
| Parallela | Avviato | 1\$1 N rami (1 contesto principale \$1 N contesti secondari) | Fino a due copie della dimensione del payload restituita da ciascun ramo, più gli stati di ogni ramo |
| Mappa | Avviato | 1\$1 N rami (1 contesto genitore\$1N contesti secondari) | Fino a due copie della dimensione del payload restituita da ogni iterazione, più gli stati di ogni iterazione |
| Aiutanti di Promise | Completato | 1 | Dimensione del payload restituita dalla promessa |
| RunInChildContext | Riuscito/non riuscito | 1 | Dimensione del payload restituita dal contesto secondario |
Per i contesti, ad esempio provenienti da `runInChildContext` o utilizzati internamente da operazioni composte, i risultati inferiori a 256 KB vengono controllati direttamente. I risultati più grandi non vengono archiviati, ma vengono ricostruiti durante la riproduzione rielaborando le operazioni del contesto.
# Runtime supportati per funzioni durevoli
Sono disponibili funzioni durevoli per determinati runtime gestiti e immagini di contenitori OCI per una maggiore flessibilità delle versioni di runtime. È possibile creare funzioni durevoli per Node.js e Python utilizzando runtime gestiti direttamente nella console o a livello di codice tramite. infrastructure-as-code Le funzioni durevoli in Java (Preview) attualmente possono essere distribuite solo tramite immagini di contenitori.
## Runtime gestiti da Lambda
I seguenti runtime gestiti supportano funzioni durevoli quando si creano funzioni nella console Lambda o si utilizza AWS CLI il parametro con `--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'` il parametro. [Per informazioni complete sui runtime Lambda, consulta Lambda runtimes.](lambda-runtimes.md)
| Lingua | Runtime |
| --- | --- |
| Node.js | nodejs 22.x |
| Node.js | nodejs24.x |
| Python | python 3.13 |
| Python | python3.14 |
**Nota**
I runtime Lambda includono l'SDK di esecuzione durevole per test e sviluppo. Tuttavia, consigliamo di includere l'SDK nel pacchetto di distribuzione per la produzione. Ciò garantisce la coerenza delle versioni ed evita potenziali aggiornamenti di runtime che potrebbero influire sul comportamento delle funzioni.
### Node.js
Installa l'SDK nel tuo progetto Node.js:
```
npm install @aws/durable-execution-sdk-js
```
L'SDK supporta JavaScript e. TypeScript Per TypeScript i progetti, l'SDK include definizioni dei tipi.
### Python
Installa l'SDK nel tuo progetto Python:
```
pip install aws-durable-execution-sdk-python
```
L'SDK Python utilizza metodi sincroni e non richiede. `async/await`
### Java (anteprima)
Aggiungi una dipendenza a`pom.xml`:
```
software.amazon.lambda.durable
aws-durable-execution-sdk-java
VERSION
```
Installa l'SDK nel tuo progetto Java:
```
mvn install
```
È disponibile una versione di anteprima di Java SDK. Le waitForCondition operazioni parallele e cartografiche sono ancora in fase di sviluppo. waitForCallback
## Immagini di container
È possibile utilizzare funzioni durevoli con immagini dei contenitori per supportare versioni di runtime aggiuntive o configurazioni di runtime personalizzate. Le immagini dei container consentono di utilizzare versioni di runtime non disponibili come runtime gestiti o di personalizzare l'ambiente di runtime.
Per creare una funzione durevole utilizzando un'immagine del contenitore:
1. Crea un Dockerfile basato su un'immagine di base Lambda
1. Installa l'SDK di esecuzione durevole nel tuo contenitore
1. Crea e invia l'immagine del contenitore ad Amazon Elastic Container Registry
1. Crea la funzione Lambda dall'immagine del contenitore con l'esecuzione durevole abilitata
### Esempio di contenitore
Crea un Dockerfile:
------
#### [ Python ]
Crea un Dockerfile per 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" ]
```
Crea un file: `requirements.txt`
```
aws-durable-execution-sdk-python
```
------
#### [ Java (Preview) ]
Crea un Dockerfile per 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"]
```
------
Crea e invia l'immagine:
```
# 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
```
Crea la funzione con l'esecuzione duratura abilitata:
```
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}'
```
Per ulteriori informazioni sull'utilizzo delle immagini dei container con Lambda, consulta Creazione di immagini di [container Lambda nella Lambda Developer](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) Guide.
## Considerazioni sul runtime
**Gestione delle versioni SDK:** includi l'SDK di esecuzione durevole nel pacchetto di distribuzione o nell'immagine del contenitore. Ciò garantisce che la funzione utilizzi una versione SDK specifica e non sia influenzata dagli aggiornamenti di runtime. Aggiungi le versioni SDK a `package.json` o `requirements.txt` per controllare quando esegui l'aggiornamento.
**Aggiornamenti in fase di esecuzione: AWS aggiorna i runtime** gestiti per includere patch di sicurezza e correzioni di bug. Questi aggiornamenti possono includere nuove versioni dell'SDK. Per evitare comportamenti imprevisti, includi l'SDK nel pacchetto di distribuzione e testalo accuratamente prima di distribuirlo in produzione.
**Dimensioni dell'immagine del contenitore:** le immagini dei contenitori hanno una dimensione massima non compressa di 10 GB. L'SDK di esecuzione durevole aggiunge dimensioni minime all'immagine. Ottimizza il tuo contenitore utilizzando build in più fasi e rimuovendo le dipendenze non necessarie.
**Prestazioni di avvio a freddo: le** immagini dei container possono avere tempi di avvio a freddo più lunghi rispetto ai runtime gestiti. L'SDK di esecuzione durevole ha un impatto minimo sulle prestazioni di avvio a freddo. Utilizza la concorrenza fornita se la latenza di avvio a freddo è fondamentale per la tua applicazione.