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à.

Concetti di base

Lambda fornisce un'esecuzione durevole SDKs per JavaScript TypeScript, e Python. Queste SDKs sono le basi per creare funzioni durevoli, che forniscono le primitive necessarie per controllare i progressi, gestire i nuovi tentativi e gestire il flusso di esecuzione. Per la documentazione e gli esempi completi sull'SDK, consulta JavaScript/TypeScript SDK e Python SDK on. GitHub

Esecuzione durevole

Un'esecuzione durevole rappresenta il ciclo di vita completo di una funzione durevole Lambda, che utilizza un meccanismo di checkpoint e replay per tracciare l'avanzamento della logica aziendale, sospendere l'esecuzione e ripristinare in caso di errori. Quando le funzioni riprendono dopo la sospensione o l'interruzione, i checkpoint precedentemente completati vengono riprodotti e la funzione continua l'esecuzione.

Il ciclo di vita può includere più invocazioni di una funzione Lambda per completare l'esecuzione, in particolare dopo sospensioni o guasti. Questo approccio consente alla funzione di funzionare per periodi prolungati (fino a un anno) mantenendo un progresso affidabile nonostante le interruzioni.

Come funziona il replay

Lambda mantiene un registro in esecuzione di tutte le operazioni durevoli (passaggi, attese e altre operazioni) durante l'esecuzione della funzione. Quando la funzione deve essere messa in pausa o incontra un'interruzione, Lambda salva questo registro dei checkpoint e interrompe l'esecuzione. Quando è il momento di riprendere, Lambda richiama nuovamente la funzione dall'inizio e riproduce il registro del checkpoint, sostituendo i valori memorizzati con le operazioni completate. Ciò significa che il codice viene eseguito nuovamente, ma i passaggi completati in precedenza non vengono rieseguiti. Al loro posto vengono utilizzati i risultati memorizzati.

Questo meccanismo di riproduzione è fondamentale per comprendere le funzioni durevoli. Il codice deve essere deterministico durante la riproduzione, il che significa che produce gli stessi risultati con gli stessi input. Evita le operazioni con effetti collaterali (come la generazione di numeri casuali o la visualizzazione dell'ora corrente) al di fuori dei passaggi, poiché queste possono produrre valori diversi durante la riproduzione e causare comportamenti non deterministici.

DurableContext

DurableContextè l'oggetto contestuale che riceve la tua funzione durevole. Fornisce metodi per operazioni durature come passaggi e attese che creano checkpoint e gestiscono il flusso di esecuzione.

La tua funzione duratura riceve un contesto Lambda DurableContext invece del contesto Lambda predefinito:

TypeScript

import {
  DurableContext,
  withDurableExecution,
} from "@aws/durable-execution-sdk-js";

export const handler = withDurableExecution(
  async (event: any, context: DurableContext) => {
    const result = await context.step(async () => {
      return "step completed";
    });
    return result;
  },
);

Python

from aws_durable_execution_sdk_python import (
    DurableContext,
    durable_execution,
    durable_step,
)

@durable_step
def my_step(step_context, data):
    # Your business logic
    return result

@durable_execution
def handler(event, context: DurableContext):
    result = context.step(my_step(event["data"]))
    return result

L'SDK Python per funzioni durevoli utilizza metodi sincroni e non supporta. await L' TypeScript SDK utilizza. async/await

Fasi

Steps esegue la logica aziendale con nuovi tentativi integrati e checkpoint automatico. Ogni passaggio salva il risultato, assicurando che la funzione possa riprendere da qualsiasi passaggio completato dopo le interruzioni.

TypeScript

// Each step is automatically checkpointed
const order = await context.step(async () => processOrder(event));
const payment = await context.step(async () => processPayment(order));
const result = await context.step(async () => completeOrder(payment));

Python

# Each step is automatically checkpointed
order = context.step(lambda: process_order(event))
payment = context.step(lambda: process_payment(order))
result = context.step(lambda: complete_order(payment))

Stati di attesa

Gli stati di attesa sono pause pianificate in cui la funzione smette di funzionare (e interrompe la ricarica) fino al momento di continuare. Utilizzali per attendere periodi di tempo, richiamate esterne o condizioni specifiche.

TypeScript

// Wait for 1 hour without consuming resources
await context.wait({ seconds:3600 });

// Wait for external callback
const approval = await context.waitForCallback(
  async (callbackId) => sendApprovalRequest(callbackId)
);

Python

# Wait for 1 hour without consuming resources
context.wait(3600)

# Wait for external callback
approval = context.wait_for_callback(
    lambda callback_id: send_approval_request(callback_id)
)

Quando la funzione incontra un'attesa o deve essere messa in pausa, Lambda salva il registro del checkpoint e interrompe l'esecuzione. Quando è il momento di riprendere, Lambda richiama nuovamente la funzione e riproduce il registro del checkpoint, sostituendo i valori memorizzati con le operazioni completate.

Per flussi di lavoro più complessi, le funzioni Lambda durevoli includono anche operazioni avanzate parallel() come l'esecuzione simultanea, l'elaborazione di array map()runInChildContext(), le operazioni annidate e il polling. waitForCondition() Vedi Esempi per esempi dettagliati e indicazioni su quando utilizzare ciascuna operazione.

Richiamo di altre funzioni

Invoke consente a una funzione durevole di chiamare altre funzioni Lambda e attendere i loro risultati. La funzione chiamante si sospende durante l'esecuzione della funzione richiamata, creando un checkpoint che conserva il risultato. Ciò consente di creare flussi di lavoro modulari in cui funzioni specializzate gestiscono attività specifiche.

context.invoke()Utilizzatelo per richiamare altre funzioni dall'interno della vostra funzione duratura. La chiamata ha un checkpoint, quindi se la funzione viene interrotta dopo il completamento della funzione richiamata, riprende con il risultato memorizzato senza richiamare nuovamente la funzione.

TypeScript

// Invoke another function and wait for result
const customerData = await context.invoke(
  'validate-customer',
  'arn:aws:lambda:us-east-1:123456789012:function:customer-service:1',
  { customerId: event.customerId }
);

// Use the result in subsequent steps
const order = await context.step(async () => {
  return processOrder(customerData);
});

Python

# Invoke another function and wait for result
customer_data = context.invoke(
    'arn:aws:lambda:us-east-1:123456789012:function:customer-service:1',
    {'customerId': event['customerId']},
    name='validate-customer'
)

# Use the result in subsequent steps
order = context.step(
    lambda: process_order(customer_data),
    name='process-order'
)

La funzione richiamata può essere una funzione Lambda durevole o standard. Se richiamate una funzione duratura, la funzione chiamante attende il completamento dell'esecuzione duratura completa. Questo modello è comune nelle architetture di microservizi in cui ogni funzione gestisce un dominio specifico e consente di comporre flussi di lavoro complessi a partire da funzioni specializzate e riutilizzabili.

Configurazione durevole delle funzioni

Le funzioni durevoli hanno impostazioni di configurazione specifiche che controllano il comportamento di esecuzione e la conservazione dei dati. Queste impostazioni sono separate dalla configurazione standard della funzione Lambda e si applicano all'intero ciclo di vita dell'esecuzione durevole.

L'DurableConfigoggetto definisce la configurazione per le funzioni durevoli:

{
  "ExecutionTimeout": Integer,
  "RetentionPeriodInDays": Integer
}

Execution timeout (Timeout di esecuzione)

Il timeout di esecuzione controlla per quanto tempo può durare un'esecuzione durevole dall'inizio al completamento. Questo è diverso dal timeout della funzione Lambda, che controlla per quanto tempo può essere eseguita una singola chiamata di funzione.

Un'esecuzione durevole può includere più chiamate di funzioni Lambda man mano che avanza attraverso checkpoint, attese e replay. Il timeout di esecuzione si applica al tempo totale trascorso dell'esecuzione durevole, non alle chiamate di singole funzioni.

Comprendere la differenza

Il timeout della funzione Lambda (massimo 15 minuti) limita ogni singola chiamata della funzione. Il timeout di esecuzione duraturo (massimo 1 anno) limita il tempo totale dall'inizio dell'esecuzione al completamento, all'errore o al timeout. Durante questo periodo, la funzione può essere richiamata più volte durante l'elaborazione delle fasi, le attese e il ripristino in caso di errori.

Ad esempio, se imposti un timeout di esecuzione duraturo di 24 ore e un timeout della funzione Lambda di 5 minuti:

Puoi configurare il timeout di esecuzione quando crei una funzione durevole utilizzando la console Lambda AWS CLI, oppure. AWS SAM Nella console Lambda, scegli la tua funzione, quindi Configurazione, Esecuzione durevole. Imposta il valore del timeout di esecuzione in secondi (impostazione predefinita: 86400 secondi/24 ore, minimo: 60 secondi, massimo: 31536000 secondi/1 anno).

Periodo di conservazione

Il periodo di conservazione controlla per quanto tempo Lambda conserva la cronologia di esecuzione e i dati dei checkpoint dopo il completamento di un'esecuzione duratura. Questi dati includono i risultati delle fasi, lo stato di esecuzione e il registro completo del checkpoint.

Dopo la scadenza del periodo di conservazione, Lambda elimina la cronologia di esecuzione e i dati del checkpoint. Non è più possibile recuperare i dettagli dell'esecuzione o ripetere l'esecuzione. Il periodo di conservazione inizia quando l'esecuzione raggiunge uno stato terminale (SUCCEEDED, FAILED, STOPED o TIMED_OUT).

Puoi configurare il periodo di conservazione quando crei una funzione durevole utilizzando la console Lambda AWS CLI, oppure. AWS SAM Nella console Lambda, scegli la tua funzione, quindi Configurazione, Esecuzione durevole. Imposta il valore del periodo di conservazione in giorni (impostazione predefinita: 14 giorni, minimo: 1 giorno, massimo: 90 giorni).

Scegli un periodo di conservazione in base ai requisiti di conformità, alle esigenze di debug e alle considerazioni relative ai costi. Periodi di conservazione più lunghi offrono più tempo per il debug e il controllo, ma aumentano i costi di storage.