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à.
# Creazione di funzioni Lambda durevoli
Per iniziare a usare le funzioni durevoli Lambda, usa la console Lambda per creare una funzione durevole. In pochi minuti, puoi creare e implementare una funzione durevole che utilizza passaggi e attese per dimostrare l'esecuzione basata su checkpoint.
Mentre svolgi il tutorial, imparerai i concetti fondamentali delle funzioni durevoli, come usare l'`DurableContext`oggetto, creare checkpoint con passaggi e mettere in pausa l'esecuzione con attese. Imparerai anche come funziona il replay quando la funzione riprende dopo un'attesa.
Per semplificare le cose, questo tutorial mostra come creare una funzione usando il runtime Python o Node.js. Con questi linguaggi interpretati, puoi modificare il codice della funzione direttamente nell'editor del codice integrato della console.
Le funzioni durevoli in Java (Preview) attualmente possono essere distribuite solo tramite immagini di container. Per ulteriori informazioni sulla creazione di funzioni durevoli dalle immagini dei container, consulta [Runtime supportati per funzioni durevoli o Implementazione delle funzioni durevoli](durable-supported-runtimes.md) [Lambda con Infrastructure](durable-getting-started-iac.md) as Code.
**Nota**
Le funzioni durevoli attualmente supportano i runtime Python e Node.js (JavaScript/TypeScript) e le immagini contenitore (OCI), come Java. Per un elenco completo delle versioni di runtime supportate e delle opzioni relative alle immagini dei contenitori, consulta [Runtime supportati per](durable-supported-runtimes.md) funzioni durevoli. 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.
**Suggerimento**
Per scoprire come creare **soluzioni serverless**, consulta la [Guida allo sviluppo serverless](https://docs.aws.amazon.com/serverless/latest/devguide/).
## Prerequisiti
### Registrati per un Account AWS
Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.
**Per iscriverti a un Account AWS**
1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)
1. Segui le istruzioni online.
Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.
Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.
### Crea un utente con accesso amministrativo
Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.
**Proteggi i tuoi Utente root dell'account AWS**
1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.
Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *.
1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.
Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.
**Crea un utente con accesso amministrativo**
1. Abilita il Centro identità IAM.
Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *.
1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.
Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.
**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.
Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.
**Assegnazione dell’accesso ad altri utenti**
1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.
Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *.
1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).
Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *.
## Crea una funzione Lambda durevole con la console
In questo esempio, la tua funzione duratura elabora un ordine attraverso più passaggi con checkpoint automatico. La funzione accetta un oggetto JSON contenente un ID dell'ordine, convalida l'ordine, elabora il pagamento e conferma l'ordine. Ogni passaggio viene controllato automaticamente, quindi se la funzione viene interrotta, riprende dall'ultimo passaggio completato.
La funzione dimostra anche un'operazione di attesa, che sospende l'esecuzione per un breve periodo per simulare l'attesa di una conferma esterna.
**Per creare una funzione duratura con la console**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli **Crea funzione**.
1. Scegli **Crea da zero**.
1. Nel riquadro **Informazioni base**, per **Nome funzione** inserisci `myDurableFunction`.
1. Per **Runtime**, scegli **Node.js 24** o **Python** 3.14.
1. Seleziona **Abilita esecuzione duratura.**
Lambda crea una funzione durevole con un [ruolo di esecuzione](lambda-intro-execution-role.md) che include le autorizzazioni per le operazioni di checkpoint (e). `lambda:CheckpointDurableExecutions` `lambda:GetDurableExecutionState`
**Nota**
I runtime Lambda includono l'SDK Durable Execution, che consente di testare funzioni durevoli senza dipendenze dai pacchetti. 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 sulla funzionalità.
Usa l'editor di codice integrato nella console per aggiungere il tuo codice funzionale durevole.
------
#### [ Node.js ]
**Per modificare il codice nella console**
1. Scegli la scheda **Codice**.
Nell'editor di codice integrato della console, dovresti vedere il codice della funzione creato da Lambda. Se non vedi la scheda **index.js** nell'editor di codice, seleziona **index.js** in Esplora file, come illustrato nel diagramma seguente.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/durable-nodejs.png)
1. Incolla il codice seguente nella scheda **index.js**, sostituendo il codice creato da Lambda.
```
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. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**Comprensione del codice funzionale durevole**
Prima di passare alla fase successiva, esaminiamo il codice della funzione e comprendiamo i concetti chiave relativi alle funzioni durevoli.
+ L'`withDurableExecution`involucro:
La tua funzione durevole è racchiusa in. `withDurableExecution` Questo wrapper consente un'esecuzione duratura fornendo l'`DurableContext`oggetto e gestendo le operazioni del checkpoint.
+ L'oggetto: `DurableContext`
Invece del contesto Lambda standard, la funzione riceve un. `DurableContext` Questo oggetto fornisce metodi per operazioni durevoli come `step()` e `wait()` che creano checkpoint.
+ Passaggi e punti di controllo:
Ogni `context.step()` chiamata crea un checkpoint prima e dopo l'esecuzione. Se la funzione viene interrotta, riprende dall'ultimo checkpoint completato. La funzione non riesegue i passaggi completati. Utilizza invece i risultati memorizzati.
+ Operazioni di attesa:
La `context.wait()` chiamata sospende l'esecuzione senza consumare risorse di calcolo. Al termine dell'attesa, Lambda richiama nuovamente la funzione e riproduce il registro del checkpoint, sostituendo i valori memorizzati con i passaggi completati.
+ Meccanismo di riproduzione:
Quando la funzione riprende dopo un'attesa o un'interruzione, Lambda esegue il codice dall'inizio. Tuttavia, i passaggi completati non vengono rieseguiti. Lambda riproduce i risultati dal registro dei checkpoint. Questo è il motivo per cui il codice deve essere deterministico.
------
#### [ Python ]
**Per modificare il codice nella console**
1. Scegli la scheda **Codice**.
Nell'editor di codice integrato della console, dovresti vedere il codice della funzione creato da Lambda. Se non vedi la scheda **lambda\$1function.py** nell'editor di codice, seleziona **lambda\$1function.py** in Esplora file, come illustrato nel diagramma seguente.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/durable-python.png)
1. Incolla il codice seguente nella scheda **lambda\$1function.py**, sostituendo il codice creato da Lambda.
```
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. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**Comprensione del codice funzionale durevole**
Prima di passare alla fase successiva, esaminiamo il codice della funzione e comprendiamo i concetti chiave relativi alle funzioni durevoli.
+ Il `@durable_execution` decoratore:
La tua funzione di gestore è decorata con. `@durable_execution` Questo decoratore consente un'esecuzione duratura fornendo l'`DurableContext`oggetto e gestendo le operazioni del checkpoint.
+ Il `@durable_step` decoratore:
Ogni funzione Step è decorata con`@durable_step`. Questo decoratore contrassegna la funzione come un gradino durevole che crea posti di blocco.
+ L'`DurableContext`oggetto:
Invece del contesto Lambda standard, la funzione riceve un. `DurableContext` Questo oggetto fornisce metodi per operazioni durevoli come `step()` e `wait()` che creano checkpoint.
+ Passaggi e punti di controllo:
Ogni `context.step()` chiamata crea un checkpoint prima e dopo l'esecuzione. Se la funzione viene interrotta, riprende dall'ultimo checkpoint completato. La funzione non riesegue i passaggi completati. Utilizza invece i risultati memorizzati.
+ Operazioni di attesa:
La `context.wait()` chiamata sospende l'esecuzione senza consumare risorse di calcolo. Al termine dell'attesa, Lambda richiama nuovamente la funzione e riproduce il registro del checkpoint, sostituendo i valori memorizzati con i passaggi completati.
+ Python SDK è sincrono:
Nota che l'SDK Python non lo usa. `await` Tutte le operazioni durevoli sono chiamate di metodo sincrone.
------
## Invoca la funzione durable utilizzando l'editor di codice della console
Quando non viene specificata (o pubblicata) alcuna versione esplicita, la console richiama la funzione durable utilizzando il qualificatore di versione. `$LATEST` Tuttavia, per l'esecuzione deterministica del codice, è necessario utilizzare sempre un ARN qualificato che punti a una versione stabile.
**Per pubblicare una versione della tua funzione**
1. Scegli la scheda **Versioni**.
1. Selezionare **Publish new version** (Pubblica nuova versione).
1. Per la **descrizione della versione**, inserisci **Initial version** (opzionale).
1. Seleziona **Pubblica**.
1. Lambda crea la versione 1 della tua funzione. Nota che la funzione ARN ora include `:1` alla fine, a indicare che si tratta della versione 1.
Ora crea un evento di test da inviare alla tua funzione. L'evento è un documento in formato JSON contenente un ID dell'ordine.
**Per creare un evento di test**
1. Nella sezione **TEST EVENTS** dell'editor di codice della console, scegli **Crea evento di test**.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/test-event.png)
1. Per **Event name** (Nome evento), immettere **myTestEvent**.
1. Nella sezione **JSON dell'evento**, sostituisci il codice JSON predefinito con il seguente:
```
{
"orderId": "order-12345"
}
```
1. Scegli **Save** (Salva).
**Per testare la tua funzione duratura e visualizzarne l'esecuzione**
Nella sezione **TEST EVENTS** dell'editor di codice della console, scegli l'icona di esecuzione accanto all'evento di test:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/run-test-event.png)
La tua funzione durevole inizia l'esecuzione. Poiché include un'attesa di 10 secondi, la chiamata iniziale viene completata rapidamente e la funzione riprende dopo il periodo di attesa. **È possibile visualizzare l'avanzamento dell'esecuzione nella scheda Esecuzioni durevoli.**
**Per visualizzare l'esecuzione duratura della funzione**
1. Scegli la scheda **Esecuzioni durevoli**.
1. Trova la tua esecuzione nell'elenco. L'esecuzione mostra lo stato attuale (In esecuzione, Riuscito o Non riuscito).
1. Scegli l'ID di esecuzione per visualizzare i dettagli, tra cui:
+ Cronologia dell'esecuzione che mostra quando ogni passaggio è stato completato
+ Cronologia dei checkpoint
+ Periodi di attesa
+ Risultati delle fasi
Puoi anche visualizzare i log della tua funzione in CloudWatch Logs per vedere l'output della console di ogni passaggio.
**Per visualizzare i record di invocazione della funzione in Logs CloudWatch**
1. Apri la pagina [Log groups](https://console.aws.amazon.com/cloudwatch/home#logs:) della console. CloudWatch
1. Scegli il nome del gruppo di log per la funzione (`/aws/lambda/myDurableFunction`).
1. Scorri verso il basso e scegli il **flusso di log** per le invocazioni delle funzioni che desideri esaminare.
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/log-stream.png)
Dovrebbero essere visualizzate le voci di registro per ogni chiamata della funzione, inclusa l'esecuzione iniziale e la riproduzione dopo l'attesa.
**Nota**
Quando si utilizza il logger di `DurableContext` (ad esempio `context.logger` o`stepContext.logger`), i log vengono visualizzati anche nelle viste Durable Execution e Step della console Lambda. Il caricamento di questi log può richiedere alcuni istanti.
## Eliminazione
Quando hai finito di utilizzare la funzione durable di esempio, eliminala. Puoi anche eliminare il gruppo di log che memorizza i log della funzione e il [ruolo di esecuzione](lambda-intro-execution-role.md) creato dalla console.
**Per eliminare la funzione Lambda**
1. Aprire la pagina [Functions (Funzioni)](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Selezionare la funzione creata.
1. Scegliere **Operazioni**, **Elimina**.
1. Inserisci **confirm** nel campo di immissione del testo, quindi scegli **Elimina**.
**Come eliminare il gruppo di log**
1. Apri la pagina [Log groups page (Pagina dei gruppi di log)](https://console.aws.amazon.com/cloudwatch/home#logs:) della console CloudWatch.
1. Scegli il gruppo di log della funzione (`/aws/lambda/myDurableFunction`).
1. Scegli **Actions (Azioni)**, **Delete log group(s) (Elimina gruppo/i di log)**.
1. Nella finestra di dialogo **Delete log group(s) (Elimina gruppo/i di log)** scegli **Delete (Elimina)**.
**Come eliminare il ruolo di esecuzione**
1. Apri la [pagina Ruoli](https://console.aws.amazon.com/iam/home?#/roles) della console AWS Identity and Access Management (IAM).
1. Seleziona il ruolo di esecuzione della funzione (ad esempio, `myDurableFunction-role-31exxmpl`).
1. Scegli **Elimina**.
1. Nella finestra di dialogo **Elimina ruolo**, immetti il nome del ruolo, quindi scegli **Elimina**.
## Risorse aggiuntive e fasi successive
Ora che hai creato e testato una funzione semplice e duratura utilizzando la console, procedi nel seguente modo:
+ Scopri i casi d'uso più comuni per funzioni durevoli, tra cui transazioni distribuite, elaborazione degli ordini e flussi di lavoro di revisione umana. Vedi [esempi](durable-examples.md).
+ Scopri come monitorare le esecuzioni durevoli delle funzioni con CloudWatch metriche e cronologia delle esecuzioni. Vedi [Monitoraggio e debug.](durable-monitoring.md)
+ Scopri come richiamare funzioni durevoli in modo sincrono e asincrono e come gestire esecuzioni di lunga durata. [Vedi Richiamo di funzioni durevoli](durable-invoking.md).
+ Segui le migliori pratiche per scrivere codice deterministico, gestire le dimensioni dei checkpoint e ottimizzare i costi. [Consulta le migliori pratiche.](durable-best-practices.md)
+ Scopri come testare funzioni durevoli a livello locale e nel cloud. Vedi [Testare funzioni durevoli](durable-testing.md).
+ Confronta le funzioni durevoli con Step Functions per capire quando ogni approccio è più efficace. Vedi [Durable functions o Step Functions](durable-step-functions.md).
# Implementa e richiama le funzioni durevoli Lambda con AWS CLI
Usa il AWS CLI per creare e distribuire funzioni durevoli Lambda con comandi imperativi. Questo approccio ti offre il controllo diretto su ogni fase del processo di distribuzione.
## Prerequisiti
+ Istalla e configura la AWS CLI. Per istruzioni, consulta [Installazione di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Crea un pacchetto di distribuzione con il codice della funzione e l'SDK di esecuzione durevole.
+ Crea un ruolo di esecuzione IAM con autorizzazioni di checkpoint.
## Creazione del ruolo di esecuzione
Crea un ruolo IAM con autorizzazioni per l'esecuzione Lambda di base e le operazioni di checkpoint.
**Per creare il ruolo di esecuzione**
1. Crea un documento sulla politica di fiducia che consenta a Lambda di assumere il ruolo. Salva questo come`trust-policy.json`:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Crea il ruolo:
```
aws iam create-role \
--role-name durable-function-role \
--assume-role-policy-document file://trust-policy.json
```
1. Allega la politica di esecuzione duratura per le operazioni di checkpoint e l'esecuzione di base:
```
aws iam attach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
```
La policy `AWSLambdaBasicDurableExecutionRolePolicy` gestita include le autorizzazioni necessarie per le operazioni di checkpoint (`lambda:CheckpointDurableExecutions`e`lambda:GetDurableExecutionState`) e l'esecuzione di base di Lambda.
## Crea la funzione duratura
Crea la tua funzione duratura con il `--durable-config` parametro.
**Per creare una funzione duratura**
1. Package del codice della funzione con le dipendenze in un file.zip:
```
zip -r function.zip index.mjs node_modules/
```
1. Crea la funzione con l'esecuzione duratura abilitata:
```
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**
È possibile abilitare l'esecuzione duratura solo durante la creazione della funzione. Non è possibile abilitarla su funzioni esistenti.
**Nota**
Attualmente le funzioni Durable in Java (Preview) possono essere create solo tramite immagini di contenitori. Per ulteriori informazioni sulla creazione di funzioni durevoli a partire da immagini di contenitori, [consultate Runtime supportati per funzioni durevoli](durable-supported-runtimes.md).
## Pubblica una versione
Sebbene le funzioni durevoli possano essere richiamate utilizzando il qualificatore di `$LATEST` versione, è necessario utilizzare sempre un ARN qualificato che punti a una versione stabile per garantire l'esecuzione deterministica del codice.
```
aws lambda publish-version \
--function-name myDurableFunction \
--description "Initial version"
```
Il comando restituisce la versione ARN. Annotate il numero di versione (ad esempio,`:1`) alla fine dell'ARN.
Facoltativamente, create un alias che punti alla versione:
```
aws lambda create-alias \
--function-name myDurableFunction \
--name prod \
--function-version 1
```
## Invoca la funzione duratura
Richiama la tua funzione duratura utilizzando l'ARN qualificato (versione o alias).
**Nota**
**Invocazioni idempotenti:** per evitare esecuzioni duplicate quando si riprova una chiamata fallita, è possibile fornire un nome di esecuzione che garantisca la semantica dell'esecuzione. at-most-once [Vedi Idempotenza per i dettagli.](durable-execution-idempotency.md)
**Invocazione sincrona**
Per le esecuzioni che vengono completate entro 15 minuti, usa la chiamata sincrona:
```
aws lambda invoke \
--function-name myDurableFunction:1 \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
O usando un alias:
```
aws lambda invoke \
--function-name myDurableFunction:prod \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
**Invocazione asincrona**
Per le esecuzioni di lunga durata, usa la chiamata asincrona:
```
aws lambda invoke \
--function-name myDurableFunction:prod \
--invocation-type Event \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
Con la chiamata asincrona, Lambda ritorna immediatamente. L'esecuzione della funzione continua in background.
**Nota**
È possibile utilizzarla `$LATEST` per la prototipazione e il test nella console. Per i carichi di lavoro di produzione, utilizza una versione o un alias pubblicati.
## Gestisci esecuzioni durevoli
Utilizzate i seguenti comandi per gestire e monitorare le esecuzioni di funzioni durevoli.
**Elenca le esecuzioni**
Elenca tutte le esecuzioni per una funzione durevole:
```
aws lambda list-durable-executions-by-function \
--function-name myDurableFunction
```
**Ottieni i dettagli dell'esecuzione**
Ottieni dettagli su un'esecuzione specifica:
```
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
```
**Ottieni la cronologia delle esecuzioni**
Visualizza la cronologia dei checkpoint per un'esecuzione:
```
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
```
**Interrompi un'esecuzione**
Interrompi un'esecuzione durevole in esecuzione:
```
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
```
## Aggiornamento del codice della funzione
Aggiorna il codice della funzione durevole e pubblica una nuova versione:
**Per aggiornare e pubblicare una nuova versione**
1. Aggiorna il codice della funzione:
```
aws lambda update-function-code \
--function-name myDurableFunction \
--zip-file fileb://function.zip
```
1. Attendi il completamento dell'aggiornamento:
```
aws lambda wait function-updated \
--function-name myDurableFunction
```
1. Pubblica una nuova versione:
```
aws lambda publish-version \
--function-name myDurableFunction \
--description "Updated order processing logic"
```
1. Aggiorna l'alias in modo che punti alla nuova versione:
```
aws lambda update-alias \
--function-name myDurableFunction \
--name prod \
--function-version 2
```
**Importante**
Le esecuzioni in esecuzione continuano a utilizzare la versione con cui sono iniziate. Le nuove chiamate utilizzano la versione aggiornata dell'alias.
## Visualizzare i log delle funzioni
Visualizza i log della tua funzione durevole in Logs: CloudWatch
```
aws logs tail /aws/lambda/myDurableFunction --follow
```
Filtra i log per un'esecuzione specifica:
```
aws logs filter-log-events \
--log-group-name /aws/lambda/myDurableFunction \
--filter-pattern "exec-abc123"
```
## Eseguire la pulizia delle risorse
Elimina la tua funzione durevole e le risorse associate:
```
# 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
```
## Fasi successive
Dopo aver implementato la funzione duratura con: AWS CLI
+ Monitora le esecuzioni utilizzando i `list-durable-executions` comandi and `get-durable-execution`
+ Visualizza le operazioni dei checkpoint negli eventi relativi ai dati AWS CloudTrail
+ Imposta CloudWatch allarmi per errori di esecuzione o esecuzioni di lunga durata
+ Automatizza le distribuzioni utilizzando script o pipeline di shell CI/CD
Per ulteriori informazioni sui AWS CLI comandi per Lambda, consulta il [AWS CLI Command](https://docs.aws.amazon.com/cli/latest/reference/lambda/index.html) Reference.
# Implementa le funzioni durevoli di Lambda con Infrastructure as Code
Puoi implementare funzioni durevoli Lambda utilizzando strumenti Infrastructure as Code (IaC) AWS CloudFormation come AWS CDK, AWS Serverless Application Model, o Terraform. Questi strumenti consentono di definire la funzione, il ruolo di esecuzione e le autorizzazioni nel codice, rendendo le distribuzioni ripetibili e controllate dalla versione.
Tutti e tre gli strumenti richiedono di:
+ Abilitare l'esecuzione duratura della funzione
+ Concedi i permessi di checkpoint al ruolo di esecuzione
+ Pubblica una versione o crea un alias (le funzioni durevoli richiedono competenze qualificate) ARNs
## Funzioni durevoli da un file ZIP
### AWS CloudFormation
CloudFormation Utilizzatelo per definire la vostra funzione duratura in un modello. L'esempio seguente crea una funzione durevole con le autorizzazioni richieste.
```
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
```
**Per distribuire il modello**
```
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-durable-function-stack \
--capabilities CAPABILITY_IAM
```
### AWS CDK
AWS CDK consente di definire l'infrastruttura utilizzando linguaggi di programmazione. I seguenti esempi mostrano come creare una funzione durevole 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'
)
```
------
**Per distribuire lo stack CDK**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM semplifica i CloudFormation modelli per le applicazioni serverless. Il modello seguente crea una funzione durevole con. 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
```
**Per distribuire il modello SAM**
```
sam build
sam deploy --guided
```
### Terraform
Terraform è un popolare strumento IaC open source che supporta le risorse. AWS L'esempio seguente crea una funzione duratura con Terraform utilizzando la versione del AWS provider 6.25.0 o successiva.
```
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
}
```
**Da distribuire con Terraform**
```
terraform init
terraform plan
terraform apply
```
**Nota**
Il supporto Terraform per le funzioni durevoli Lambda AWS richiede la versione del provider 6.25.0 o successiva. Aggiorna la versione del provider se utilizzi una versione precedente.
## Funzioni durevoli da un'immagine del contenitore OCI
È inoltre possibile creare funzioni Durable basate sulle immagini dei contenitori. Per istruzioni su come creare un'immagine del contenitore, consulta [Runtime supportati per funzioni durevoli](durable-supported-runtimes.md).
### AWS CDK
AWS CDK consente di definire l'infrastruttura utilizzando linguaggi di programmazione. I seguenti esempi mostrano come creare una funzione durevole utilizzando l'immagine TypeScript di un contenitore.
```
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',
});
}
}
```
**Per distribuire lo stack CDK**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM semplifica i CloudFormation modelli per le applicazioni serverless. Il modello seguente crea una funzione durevole con. 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
```
**Per distribuire il modello SAM**
```
sam build
sam deploy --guided
```
## Modelli di configurazione comuni
Indipendentemente dallo strumento IaC utilizzato, segui questi schemi per funzioni durevoli:
**Abilita un'esecuzione duratura**
Imposta la `DurableConfig` proprietà sulla tua funzione per abilitare l'esecuzione duratura. Questa proprietà è disponibile solo durante la creazione della funzione. Non è possibile abilitare l'esecuzione duratura di funzioni esistenti.
**Concedi le autorizzazioni per i checkpoint**
Allega la policy `AWSLambdaBasicDurableExecutionRolePolicy` gestita al ruolo di esecuzione. Questa politica include i requisiti `lambda:CheckpointDurableExecutions` e `lambda:GetDurableExecutionState` le autorizzazioni.
**Usa qualificati ARNs**
Crea una versione o un alias per la tua funzione. Le funzioni durevoli richiedono una ARNs chiamata qualificata (con versione o alias). Usa AWS SAM o crea versioni esplicite `AutoPublishAlias` in CloudFormation, AWS CDK e Terraform.
**Dipendenze dei pacchetti**
Includi l'SDK di esecuzione durevole nel tuo pacchetto di distribuzione. Per Node.js, installa`@aws/durable-execution-sdk-js`. Per Python, installa. `aws-durable-execution-sdk-python`
## Fasi successive
Dopo aver implementato la tua funzione duratura:
+ Verifica la tua funzione utilizzando l'ARN qualificato (versione o alias)
+ Monitora l'avanzamento dell'esecuzione nella console Lambda nella scheda Esecuzioni durevoli
+ Visualizza le operazioni dei checkpoint negli eventi relativi ai dati AWS CloudTrail
+ Consulta CloudWatch i registri per verificare l'output delle funzioni e il comportamento di riproduzione
Per ulteriori informazioni sulla distribuzione delle funzioni Lambda con gli strumenti IAc, vedere:
+ [CloudFormation AWS::Lambda::Function riferimento](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Documentazione del modulo Lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM Guida per gli sviluppatori](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)