

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

# Runtime supportati per funzioni durevoli
<a name="durable-supported-runtimes"></a>

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, Python e Java utilizzando runtime gestiti direttamente nella console o a livello di codice tramite. infrastructure-as-code

## Runtime gestiti da Lambda
<a name="durable-managed-runtimes"></a>

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 | 
| Java | java17 | 
| Java | java 21 | 
| Java | java25 | 

**Nota**  
I runtime Lambda Node.js e Python 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. Poiché Java è un linguaggio compilato, i runtime Lambda Java non includono l'SDK di esecuzione durevole, quindi deve essere incluso nel pacchetto di distribuzione.

### Node.js
<a name="durable-runtime-nodejs"></a>

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
<a name="durable-runtime-python"></a>

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
<a name="durable-runtime-java"></a>

Aggiungi una dipendenza a: `pom.xml`

```
<dependency>
    <groupId>software.amazon.lambda.durable</groupId>
    <artifactId>aws-durable-execution-sdk-java</artifactId>
    <version>VERSION</version>
</dependency>
```

Installa l'SDK nel tuo progetto Java:

```
mvn install
```

L'SDK Java fornisce versioni sincrone e asincrone di ciascun metodo.

## Immagini di container
<a name="durable-container-images"></a>

È 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
<a name="durable-container-python"></a>

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 ]

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
<a name="durable-runtime-considerations"></a>

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