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.
**Nota**
Le funzioni durevoli attualmente supportano i runtime Python, Node.js (JavaScript/TypeScript) e Java, oltre alle immagini dei contenitori (OCI). Per un elenco completo delle versioni di runtime supportate e delle opzioni relative alle immagini dei contenitori, [consultate 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:CheckpointDurableExecution` `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.
1. Incolla il codice seguente nella scheda **index.js**, sostituendo il codice creato da Lambda.
```
import {
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:
**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\_function.py** nell'editor di codice, seleziona **lambda\_function.py** in Esplora file, come illustrato nel diagramma seguente.
1. Incolla il codice seguente nella scheda **lambda\_function.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:
**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**.
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:
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.
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).
+ Confrontate le funzioni durevoli con Step Functions per capire quando ogni approccio è più efficace. Vedi [Durable functions o Step Functions](durable-step-functions.md).