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. # Implementieren Sie Code vor oder nach Lambda-Funktions-Snapshots Sie können Laufzeit-Hooks verwenden, um Code zu implementieren, bevor Lambda einen Snapshot erstellt oder nachdem Lambda eine Funktion aus einem Snapshot fortsetzt. Laufzeit-Hooks sind für eine Vielzahl von Zwecken nützlich, z. B.: + **Bereinigung und Initialisierung:** Bevor ein Snapshot erstellt wird, können Sie einen Laufzeit-Hook verwenden, um Bereinigungs- oder Ressourcenfreigabeoperationen durchzuführen. Nachdem ein Snapshot wiederhergestellt wurde, können Sie einen Laufzeit-Hook verwenden, um alle Ressourcen oder Zustände, die nicht im Snapshot erfasst wurden, neu zu initialisieren. + **Dynamische Konfiguration:** Sie können Laufzeit-Hooks verwenden, um die Konfiguration oder andere Metadaten dynamisch zu aktualisieren, bevor ein Snapshot erstellt wird oder nachdem er wiederhergestellt wurde. Dies kann nützlich sein, wenn sich Ihre Funktion an Änderungen in der Laufzeitumgebung anpassen muss. + **Externe Integrationen:** Sie können Laufzeit-Hooks zur Integration mit externen Diensten oder Systemen verwenden, z. B. zum Senden von Benachrichtigungen oder zum Aktualisieren des externen Status als Teil des Checkpointing- und Wiederherstellungsprozesses. + **Leistungsoptimierung:** Sie können Laufzeit-Hooks verwenden, um die Startsequenz Ihrer Funktion fein abzustimmen, z. B. durch Vorladen von Abhängigkeiten. Weitere Informationen finden Sie unter [Leistungsoptimierung](snapstart-best-practices.md#snapstart-tuning). Auf den folgenden Seiten wird erläutert, wie Sie Laufzeit-Hooks für Ihre bevorzugte Laufzeitumgebung implementieren. **Topics** + [Java](snapstart-runtime-hooks-java.md) + [Python](snapstart-runtime-hooks-python.md) + [.NET](snapstart-runtime-hooks-dotnet.md) # SnapStart Lambda-Laufzeit-Hooks für Java Sie können Laufzeit-Hooks verwenden, um Code zu implementieren, bevor Lambda einen Snapshot erstellt oder nachdem Lambda eine Funktion aus einem Snapshot fortsetzt. Runtime-Hooks sind als Teil des Open-Source-Projekts Coordinated Restore at Checkpoint (CRaC) verfügbar. CRaC befindet sich in der Entwicklung für das [Open Java Development Kit (OpenJDK](https://wiki.openjdk.org/display/crac)). Ein Beispiel für die Verwendung von CRa C mit einer Referenzanwendung finden Sie im [CRaC-Repository](https://github.com/CRaC/docs/blob/master/STEP-BY-STEP.md) unter. GitHub CRaC verwendet drei Hauptelemente: + `Resource` – Eine Schnittstelle mit zwei Methoden, `beforeCheckpoint()` und `afterRestore()`. Verwenden Sie diese Methoden, um den Code zu implementieren, den Sie vor einem Snapshot und nach einer Wiederherstellung ausführen möchten. + `Context ` – Um Benachrichtigungen für Prüfpunkte und Wiederherstellungen zu erhalten, muss eine `Resource` mit einem `Context` registriert sein. + `Core` – Der Koordinationsservice, der das standardmäßige globale `Context` über die statische Methode `Core.getGlobalContext()` bereitstellt. Weitere Informationen zu `Context` und `Resource` finden Sie unter [Package org.crac](https://javadoc.io/doc/io.github.crac/org-crac/latest/index.html) in der CRa C-Dokumentation. Gehen Sie wie folgt vor, um Laufzeit-Hooks mit dem [Paket org.crac](https://github.com/CRaC/org.crac) zu implementieren. Die Lambda-Laufzeit enthält eine benutzerdefinierte CRa C-Kontextimplementierung, die Ihre Runtime-Hooks vor dem Checkpointing und nach der Wiederherstellung aufruft. ## Registrierung und Ausführung von Laufzeit-Hooks Die Reihenfolge, in der Lambda Ihre Laufzeit-Hooks ausführt, wird durch die Reihenfolge der Registrierung bestimmt. Die Reihenfolge der Registrierung entspricht der Reihenfolge des Imports, der Definition oder der Ausführung in Ihrem Code. + `beforeCheckpoint()`: Wird in umgekehrter Reihenfolge der Registrierung ausgeführt + `afterRestore()`: Wird in Reihenfolge der Registrierung ausgeführt Vergewissern Sie sich, dass alle registrierten Hooks ordnungsgemäß importiert und in den Code Ihrer Funktion aufgenommen wurden. Wenn Sie Laufzeit-Hooks in einer separaten Datei oder einem Modul registrieren, müssen Sie sicherstellen, dass das Modul entweder direkt oder als Teil eines größeren Pakets in der Handler-Datei Ihrer Funktion importiert wird. Wenn die Datei oder das Modul nicht in den Funktionshandler importiert wird, ignoriert Lambda die Laufzeithaken. **Anmerkung** Wenn Lambda einen Snapshot erstellt, kann Ihr Initialisierungscode bis zu 15 Minuten lang ausgeführt werden. Das Zeitlimit beträgt 130 Sekunden oder das [konfigurierte Funktions-Timeout](configuration-timeout.md) (maximal 900 Sekunden), je nachdem, welcher Wert höher ist. Ihre `beforeCheckpoint()`-Laufzeit-Hooks werden auf das Zeitlimit des Initialisierungscodes angerechnet. Wenn Lambda einen Snapshot wiederherstellt, muss die Laufzeit geladen werden und `afterRestore()`-Laufzeit-Hooks müssen innerhalb des Timeout-Limits (10 Sekunden) abgeschlossen werden. Andernfalls erhalten Sie eine. SnapStartTimeoutException ## Schritt 1: Aktualisieren der Entwicklungskonfiguration Fügen Sie die `org.crac`-Abhängigkeit zur Entwicklungskonfiguration hinzu. Im folgenden Beispiel wird Gradle verwendet. Beispiele für andere Entwicklungssysteme finden Sie in der [Apache-Maven-Dokumentation](https://search.maven.org/artifact/io.github.crac/org-crac/0.1.3/jar). ``` dependencies { compile group: 'com.amazonaws', name: 'aws-lambda-java-core', version: '1.2.1' # All other project dependecies go here: # ... # Then, add the org.crac dependency: implementation group: 'org.crac', name: 'crac', version: '1.4.0' } ``` ## Schritt 2: Aktualisieren des Lambda-Handlers Der Lambda-Funktions*handler* ist die Methode in Ihrem Funktionscode, die Ereignisse verarbeitet. Wenn Ihre Funktion aufgerufen wird, führt Lambda die Handler-Methode aus. Ihre Funktion wird so lange ausgeführt, bis der Handler eine Antwort zurückgibt, beendet wird oder ein Timeout auftritt. Weitere Informationen finden Sie unter [Definieren des Lambda-Funktions-Handlers in Java](java-handler.md). Der folgende Beispielhandler zeigt, wie Code vor Checkpointing (`beforeCheckpoint()`) und nach der Wiederherstellung (`afterRestore()`) ausgeführt wird. Dieser Handler registriert auch die `Resource` im Laufzeit-verwalteten globalen `Context`. **Anmerkung** Wenn Lambda einen Snapshot erstellt, kann Ihr Initialisierungscode bis zu 15 Minuten lang ausgeführt werden. Das Zeitlimit beträgt 130 Sekunden oder das [konfigurierte Funktions-Timeout](configuration-timeout.md) (maximal 900 Sekunden), je nachdem, welcher Wert höher ist. Ihre `beforeCheckpoint()`-Laufzeit-Hooks werden auf das Zeitlimit des Initialisierungscodes angerechnet. Wenn Lambda einen Snapshot wiederherstellt, muss die Laufzeit (JVM) geladen werden und `afterRestore()`-Laufzeit-Hooks müssen innerhalb des Timeout-Limits (10 Sekunden) abgeschlossen werden. Andernfalls bekommst du eine SnapStartTimeoutException. ``` ... import org.crac.Resource; import org.crac.Core; ... public class CRaCDemo implements RequestStreamHandler, Resource { public CRaCDemo() { Core.getGlobalContext().register(this); } public String handleRequest(String name, Context context) throws IOException { System.out.println("Handler execution"); return "Hello " + name; } @Override public void beforeCheckpoint(org.crac.Context context) throws Exception { System.out.println("Before checkpoint"); } @Override public void afterRestore(org.crac.Context context) throws Exception { System.out.println("After restore"); ``` Der `Context` verwaltet nur ein [https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ref/WeakReference.html](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/ref/WeakReference.html) auf dem registrierten Objekt. Wenn für eine [https://javadoc.io/static/io.github.crac/org-crac/0.1.3/org/crac/Resource.html](https://javadoc.io/static/io.github.crac/org-crac/0.1.3/org/crac/Resource.html) eine Garbage Collection durchgeführt wird, werden Laufzeit-Hooks nicht ausgeführt. Ihr Code muss einen starken Verweis auf die `Resource` beibehalten, um sicherzustellen, dass der Laufzeit-Hook ausgeführt wird. Hier sind zwei Beispiele für zu vermeidende Muster: **Example – Objekt ohne starke Referenz** ``` Core.getGlobalContext().register( new MyResource() ); ``` **Example – Objekte anonymer Klassen** ``` Core.getGlobalContext().register( new Resource() { @Override public void afterRestore(Context context) throws Exception { // ... } @Override public void beforeCheckpoint(Context context) throws Exception { // ... } } ); ``` Behalten Sie stattdessen eine starke Referenz bei. Im folgenden Beispiel wird die registrierte Ressource nicht von der Garbage Collection erfasst und Laufzeit-Hooks werden konsistent ausgeführt. **Example – Objekt mit starker Referenz** ``` Resource myResource = new MyResource(); // This reference must be maintained to prevent the registered resource from being garbage collected Core.getGlobalContext().register( myResource ); ``` # Lambda SnapStart-Laufzeit-Hooks für Python Sie können Laufzeit-Hooks verwenden, um Code zu implementieren, bevor Lambda einen Snapshot erstellt oder nachdem Lambda eine Funktion aus einem Snapshot fortsetzt. Python-Laufzeit-Hooks sind als Teil der Open-Source-[Bibliothek Snapshot Restore für Python](https://pypi.org/project/snapshot-restore-py/) verfügbar, die in den von Python verwalteten Laufzeiten enthalten ist. Diese Bibliothek bietet zwei Dekoratoren, mit denen Sie Ihre Laufzeit-Hooks definieren können: + `@register_before_snapshot`: Für Funktionen, die Sie ausführen möchten, bevor Lambda einen Snapshot erstellt. + `@register_after_restore`: Für Funktionen, die Sie ausführen möchten, wenn Lambda eine Funktion aus einem Snapshot wieder aufnimmt. Alternativ können Sie auch die folgenden Methoden verwenden, um Callables für Laufzeit-Hooks zu registrieren: + `register_before_snapshot(func, *args, **kwargs)` + `register_after_restore(func, *args, **kwargs)` ## Registrierung und Ausführung von Laufzeit-Hooks Die Reihenfolge, in der Lambda Ihre Laufzeit-Hooks ausführt, wird durch die Reihenfolge der Registrierung bestimmt: + Vor dem Snapshot: Wird in umgekehrter Reihenfolge der Registrierung ausgeführt + Nach dem Snapshot: Wird in Reihenfolge der Registrierung ausgeführt Die Reihenfolge der Registrierung von Hooks zur Laufzeit hängt davon ab, wie Sie die Hooks definieren. Wenn Sie Dekoratoren (`@register_before_snapshot` und `@register_after_restore`) verwenden, folgt die Reihenfolge der Registrierung der Reihenfolge des Imports, der Definition oder der Ausführung in Ihrem Code. Wenn Sie mehr Kontrolle über die Registrierungsreihenfolge benötigen, verwenden Sie die `register_before_snapshot()`- und `register_after_restore()`-Methoden anstelle von Dekoratoren. Vergewissern Sie sich, dass alle registrierten Hooks ordnungsgemäß importiert und in den Code Ihrer Funktion aufgenommen wurden. Wenn Sie Laufzeit-Hooks in einer separaten Datei oder einem Modul registrieren, müssen Sie sicherstellen, dass das Modul entweder direkt oder als Teil eines größeren Pakets in der Handler-Datei Ihrer Funktion importiert wird. Wenn die Datei oder das Modul nicht in den Funktionshandler importiert wird, ignoriert Lambda die Laufzeithaken. **Anmerkung** Wenn Lambda einen Snapshot erstellt, kann Ihr Initialisierungscode bis zu 15 Minuten lang ausgeführt werden. Das Zeitlimit beträgt 130 Sekunden oder das [konfigurierte Funktions-Timeout](configuration-timeout.md) (maximal 900 Sekunden), je nachdem, welcher Wert höher ist. Ihre `@register_before_snapshot`-Laufzeit-Hooks werden auf das Zeitlimit des Initialisierungscodes angerechnet. Wenn Lambda einen Snapshot wiederherstellt, muss die Laufzeit geladen werden und `@register_after_restore`-Laufzeit-Hooks müssen innerhalb des Timeout-Limits (10 Sekunden) abgeschlossen werden. Andernfalls erhalten Sie eine SnapStartTimeoutException. ## Beispiel Der folgende Beispielhandler zeigt, wie Code vor Checkpointing (`@register_before_snapshot`) und nach der Wiederherstellung (`@register_after_restore`) ausgeführt wird. ``` from snapshot_restore_py import register_before_snapshot, register_after_restore def lambda_handler(event, context): # Handler code @register_before_snapshot def before_checkpoint(): # Logic to be executed before taking snapshots @register_after_restore def after_restore(): # Logic to be executed after restore ``` Weitere Beispiele finden Sie unter [Snapshot Restore für Python](https://github.com/aws/snapshot-restore-py/tree/main/examples) im AWS GitHub-Repository. # Lambda SnapStart-Laufzeit-Hooks für .NET Sie können Laufzeit-Hooks verwenden, um Code zu implementieren, bevor Lambda einen Snapshot erstellt oder nachdem Lambda eine Funktion aus einem Snapshot fortsetzt. .NET-Laufzeit-Hooks sind als Teil des [Amazon.Lambda.Core](https://www.nuget.org/packages/Amazon.Lambda.Core)-Pakets (Version 2.5.0 oder höher) verfügbar. Diese Bibliothek bietet zwei Methoden, mit denen Sie Ihre Laufzeit-Hooks definieren können: + `RegisterBeforeSnapshot()`: Code, der vor der Snapshot-Erstellung ausgeführt werden soll + `RegisterAfterSnapshot()`: Code, der nach der Wiederaufnahme einer Funktion aus einem Snapshot ausgeführt wird **Anmerkung** Wenn Sie das [Lambda Annotations Framework für .NET](csharp-handler.md#csharp-handler-annotations) verwenden, führen Sie ein Upgrade auf [Amazon.Lambda.Annotations](https://www.nuget.org/packages/Amazon.Lambda.Annotations) Version 1.6.0 oder höher durch, um die Kompatibilität mit SnapStart sicherzustellen. ## Registrierung und Ausführung von Laufzeit-Hooks Registrieren Sie Ihre Hooks in Ihrem Initialisierungscode. Beachten Sie die folgenden Richtlinien, die auf dem [Ausführungsmodell](csharp-handler.md#csharp-handler-setup) Ihrer Lambda-Funktion basieren: + Für den [Ansatz der ausführbaren Assemblierung](csharp-handler.md#csharp-executable-assembly-handlers) müssen Sie Ihre Hooks registrieren, bevor Sie den Lambda-Bootstrap mit `RunAsync` starten. + Für den [Ansatz der Klassenbibliothek](csharp-handler.md#csharp-class-library-handlers) registrieren Sie Ihre Hooks im Konstruktor der Handler-Klasse. + Für [ASP.NET Core-Anwendungen](csharp-package-asp.md) registrieren Sie Ihre Hooks, bevor Sie die `WebApplications.Run`-Methode aufrufen. Um Laufzeit-Hooks für SnapStart in .NET zu registrieren, verwenden Sie die folgenden Methoden: ``` Amazon.Lambda.Core.SnapshotRestore.RegisterBeforeSnapshot(BeforeCheckpoint); Amazon.Lambda.Core.SnapshotRestore.RegisterAfterRestore(AfterCheckpoint); ``` Wenn mehrere Hook-Typen registriert sind, wird die Reihenfolge, in der Lambda Ihre Laufzeit-Hooks ausführt, durch die Reihenfolge der Registrierung bestimmt: + `RegisterBeforeSnapshot()`: Wird in umgekehrter Reihenfolge der Registrierung ausgeführt + `RegisterAfterSnapshot()`: Wird in Reihenfolge der Registrierung ausgeführt **Anmerkung** Wenn Lambda einen Snapshot erstellt, kann Ihr Initialisierungscode bis zu 15 Minuten lang ausgeführt werden. Das Zeitlimit beträgt 130 Sekunden oder das [konfigurierte Funktions-Timeout](configuration-timeout.md) (maximal 900 Sekunden), je nachdem, welcher Wert höher ist. Ihre `RegisterBeforeSnapshot()`-Laufzeit-Hooks werden auf das Zeitlimit des Initialisierungscodes angerechnet. Wenn Lambda einen Snapshot wiederherstellt, muss die Laufzeit geladen werden und `RegisterAfterSnapshot()`-Laufzeit-Hooks müssen innerhalb des Timeout-Limits (10 Sekunden) abgeschlossen werden. Andernfalls erhalten Sie eine SnapStartTimeoutException. ## Beispiel Die folgende Beispielfunktion zeigt, wie Code vor Checkpointing (`RegisterBeforeSnapshot`) und nach der Wiederherstellung (`RegisterAfterRestore`) ausgeführt wird. ``` public class SampleClass { public SampleClass() { Amazon.Lambda.Core.SnapshotRestore.RegisterBeforeSnapshot(BeforeCheckpoint); Amazon.Lambda.Core.SnapshotRestore.RegisterAfterRestore(AfterCheckpoint); } private ValueTask BeforeCheckpoint() { // Add logic to be executed before taking the snapshot return ValueTask.CompletedTask; } private ValueTask AfterCheckpoint() { // Add logic to be executed after restoring the snapshot return ValueTask.CompletedTask; } public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context) { // Add business logic return new APIGatewayProxyResponse { StatusCode = 200 }; } } ```