

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Unterstützte Laufzeiten für langlebige Funktionen
<a name="durable-supported-runtimes"></a>

Dauerhafte Funktionen sind für ausgewählte verwaltete Laufzeiten und OCI-Container-Images für zusätzliche Flexibilität bei Laufzeitversionen verfügbar. Sie können dauerhafte Funktionen für Node.js, Python und Java mithilfe verwalteter Laufzeiten direkt in der Konsole oder programmgesteuert erstellen. infrastructure-as-code

## Von Lambda verwaltete Laufzeiten
<a name="durable-managed-runtimes"></a>

Die folgenden verwalteten Laufzeiten unterstützen dauerhafte Funktionen, wenn Sie Funktionen in der Lambda-Konsole erstellen oder AWS CLI mit dem `--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'` Parameter verwenden. Vollständige Informationen zu Lambda-Laufzeiten finden Sie unter [Lambda-Laufzeiten](lambda-runtimes.md).


| Sprache | Laufzeit | 
| --- | --- | 
| Node.js | nodejs2.x | 
| Node.js | nodejs24.x | 
| Python | Python 3.13 | 
| Python | Python 3,14 | 
| Java | java17 | 
| Java | Java 21 | 
| Java | java 25 | 

**Anmerkung**  
Die Laufzeiten von Lambda Node.js und Python enthalten das Durable Execution SDK für Tests und Entwicklung. Wir empfehlen jedoch, das SDK in Ihr Bereitstellungspaket für die Produktion aufzunehmen. Dadurch wird die Versionskonsistenz gewährleistet und potenzielle Laufzeitaktualisierungen vermieden, die Ihr Funktionsverhalten beeinträchtigen könnten. Da Java eine kompilierte Sprache ist, enthalten Lambda-Java-Laufzeiten das Durable Execution SDK nicht, sodass es in Ihrem Bereitstellungspaket enthalten sein muss.

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

Installieren Sie das SDK in Ihrem Projekt Node.js:

```
npm install @aws/durable-execution-sdk-js
```

Das SDK unterstützt JavaScript und TypeScript. Für TypeScript Projekte enthält das SDK Typdefinitionen.

### Python
<a name="durable-runtime-python"></a>

Installieren Sie das SDK in Ihrem Python-Projekt:

```
pip install aws-durable-execution-sdk-python
```

Das Python-SDK verwendet synchrone Methoden und benötigt `async/await` keine.

### Java
<a name="durable-runtime-java"></a>

Fügen Sie eine Abhängigkeit hinzu zu`pom.xml`:

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

Installieren Sie das SDK in Ihrem Java-Projekt:

```
mvn install
```

Das Java-SDK bietet sowohl synchrone als auch asynchrone Versionen jeder Methode.

## Container-Images
<a name="durable-container-images"></a>

Sie können dauerhafte Funktionen mit Container-Images verwenden, um zusätzliche Laufzeitversionen oder benutzerdefinierte Laufzeitkonfigurationen zu unterstützen. Mit Container-Images können Sie Laufzeitversionen verwenden, die nicht als verwaltete Laufzeiten verfügbar sind, oder Ihre Laufzeitumgebung anpassen.

So erstellen Sie eine dauerhafte Funktion mithilfe eines Container-Images:

1. Erstellen Sie ein Dockerfile basierend auf einem Lambda-Basisimage

1. Installieren Sie das Durable Execution SDK in Ihrem Container

1. Erstellen Sie das Container-Image und übertragen Sie es an Amazon Elastic Container Registry

1. Erstellen Sie die Lambda-Funktion aus dem Container-Image mit aktivierter dauerhafter Ausführung

### Beispiel für einen Container
<a name="durable-container-python"></a>

Erstellen Sie ein Dockerfile:

------
#### [ Python ]

Erstellen Sie ein Dockerfile für 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" ]
```

Erstelle eine Datei: `requirements.txt`

```
aws-durable-execution-sdk-python
```

------
#### [ Java ]

Erstellen Sie ein Dockerfile für 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"]
```

------

Erstellen Sie das Image und übertragen Sie es:

```
# 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
```

Erstellen Sie die Funktion mit aktivierter dauerhafter Ausführung:

```
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}'
```

Weitere Informationen zur Verwendung von Container-Images mit Lambda finden Sie unter [Creating Lambda container images](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) im Lambda Developer Guide.

## Überlegungen zur Laufzeit
<a name="durable-runtime-considerations"></a>

**SDK-Versionsverwaltung: Nehmen** Sie das Durable Execution SDK in Ihr Bereitstellungspaket oder Container-Image auf. Dadurch wird sichergestellt, dass Ihre Funktion eine bestimmte SDK-Version verwendet und nicht durch Runtime-Updates beeinträchtigt wird. Stecken Sie SDK-Versionen in Ihren PC `package.json``requirements.txt`, um zu kontrollieren, wann Sie ein Upgrade durchführen.

** AWS Runtime-Updates:** aktualisiert verwaltete Laufzeiten um Sicherheitspatches und Bugfixes. Diese Updates können neue SDK-Versionen enthalten. Um unerwartetes Verhalten zu vermeiden, nehmen Sie das SDK in Ihr Bereitstellungspaket auf und testen Sie es gründlich, bevor Sie es in der Produktion einsetzen.

**Größe des Container-Images:** Container-Images haben eine maximale unkomprimierte Größe von 10 GB. Das Durable Execution SDK fügt Ihrem Bild eine minimale Größe hinzu. Optimieren Sie Ihren Container, indem Sie mehrstufige Builds verwenden und unnötige Abhängigkeiten entfernen.

**Kaltstartleistung:** Container-Images haben möglicherweise längere Kaltstartzeiten als verwaltete Laufzeiten. Das langlebige Ausführungs-SDK hat nur minimale Auswirkungen auf die Kaltstartleistung. Verwenden Sie die bereitgestellte Parallelität, wenn die Kaltstart-Latenz für Ihre Anwendung entscheidend ist.