Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Implémentation du code avant ou après les instantanés de fonctions Lambda
Vous pouvez utiliser des hooks d’exécution pour implémenter du code avant que Lambda ne crée un instantané ou après que Lambda ait repris une fonction à partir d’un instantané. Les hooks d’exécution sont utiles à diverses fins, telles que :
+ **Le nettoyage et l’initialisation :** avant de créer un instantané, vous pouvez utiliser un hook d’exécution pour effectuer des opérations de nettoyage ou de libération de ressources. Après la restauration d’un instantané, vous pouvez utiliser un hook d’exécution pour réinitialiser les ressources ou les états qui n’ont pas été capturés dans l’instantané.
+ **La configuration dynamique :** vous pouvez utiliser des hooks d’exécution pour mettre à jour dynamiquement la configuration ou d’autres métadonnées avant la création d’un instantané ou après sa restauration. Cela peut être utile si votre fonction doit s’adapter aux modifications de l’environnement d’exécution.
+ **Les intégrations externes :** vous pouvez utiliser des hooks d’exécution pour intégrer des services ou des systèmes externes, tels que l’envoi de notifications ou la mise à jour de l’état externe, dans le cadre du processus de point de contrôle et de restauration.
+ **L’optimisation des performances :** vous pouvez utiliser des hooks d’exécution pour optimiser la séquence de démarrage de votre fonction, par exemple en préchargeant les dépendances. Pour de plus amples informations, consultez [Personnalisation de performances](snapstart-best-practices.md#snapstart-tuning).
Les pages suivantes expliquent comment implémenter des hooks d’exécution pour votre environnement d’exécution préféré.
**Topics**
+ [Java](snapstart-runtime-hooks-java.md)
+ [Python](snapstart-runtime-hooks-python.md)
+ [.NET](snapstart-runtime-hooks-dotnet.md)
# Hooks d' SnapStart exécution Lambda pour Java
Vous pouvez utiliser des hooks d’exécution pour implémenter du code avant que Lambda ne crée un instantané ou après que Lambda ait repris une fonction à partir d’un instantané. Les hooks d'exécution sont disponibles dans le cadre du projet open source Coordinated Restore at Checkpoint (CRaC). CRaC est en cours de développement pour le [kit de développement Open Java (OpenJDK](https://wiki.openjdk.org/display/crac)). Pour un exemple d'utilisation de CRa C avec une application de référence, consultez le référentiel [CRaC](https://github.com/CRaC/docs/blob/master/STEP-BY-STEP.md) sur GitHub. CRaC utilise trois éléments principaux :
+ `Resource` – Une interface avec deux méthodes, `beforeCheckpoint()` et `afterRestore()`. Utilisez ces méthodes pour implémenter le code que vous voulez exécuter avant un instantané et après une restauration.
+ `Context ` – Pour recevoir des notifications pour les points de contrôle et les restaurations, une `Resource` doit être enregistrée avec un `Context`.
+ `Core` – Le service de coordination, qui fournit le `Context` global par défaut via la méthode statique `Core.getGlobalContext()`.
Pour plus d'informations sur `Context` et`Resource`, consultez [Package org.crac dans la CRa documentation C.](https://javadoc.io/doc/io.github.crac/org-crac/latest/index.html)
Suivez les étapes suivantes pour implémenter des hooks d’exécution avec le [package org.crac](https://github.com/CRaC/org.crac). Le moteur d'exécution Lambda contient une implémentation de contexte CRa C personnalisée qui appelle vos hooks d'exécution avant le point de contrôle et après la restauration.
## Enregistrement et exécution du hook d’exécution
L’ordre dans lequel Lambda exécute vos hooks d’exécution est déterminé par l’ordre d’enregistrement. L’ordre d’enregistrement suit l’ordre d’importation, de définition ou d’exécution dans votre code.
+ `beforeCheckpoint()` : exécutés dans l’ordre inverse de l’enregistrement
+ `afterRestore()` : exécutés dans l’ordre d’enregistrement
Assurez-vous que tous les hooks enregistrés sont correctement importés et inclus dans le code de votre fonction. Si vous enregistrez les hooks d’exécution dans un fichier ou un module distinct, vous devez vous assurer que le module est importé, soit directement, soit dans le cadre d’un package plus large, dans le fichier de gestionnaire de votre fonction. Si le fichier ou le module n’est pas importé dans le gestionnaire de fonctions, Lambda ignore les hooks d’exécution.
**Note**
Lorsque Lambda crée un instantané, votre code d’initialisation peut s’exécuter jusqu’à 15 minutes. Le délai d’attente est de 130 secondes ou le [délai d’expiration de la fonction configurée](configuration-timeout.md) (900 secondes au maximum), la valeur la plus élevée étant retenue. Vos hooks d’exécution `beforeCheckpoint()` sont comptabilisés dans le délai d’attente du code d’initialisation. Lorsque Lambda restaure un instantané, l’exécution doit se charger et les hooks d’exécution `afterRestore()` doivent se terminer dans le délai imparti (10 secondes). Sinon, vous obtiendrez un SnapStartTimeoutException.
## Étape 1 : mettre à jour de configuration de création
Ajoutez la dépendance `org.crac` à la configuration de compilation. L’exemple suivant utilise Gradle. Pour des exemples concernant d’autres systèmes de compilation, consultez la [documentation Apache Maven](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'
}
```
## Étape 2 : mettre à jour le gestionnaire Lambda
Le *gestionnaire* de fonction Lambda est la méthode dans votre code de fonction qui traite les événements. Lorsque votre fonction est invoquée, Lambda exécute la méthode du gestionnaire. Votre fonction s’exécute jusqu’à ce que le gestionnaire renvoie une réponse, se ferme ou expire.
Pour de plus amples informations, veuillez consulter [Définition du gestionnaire de fonction Lambda dans Java](java-handler.md).
L’exemple de gestionnaire suivant montre comment exécuter le code avant le point de contrôle (`beforeCheckpoint()`) et après la restauration (`afterRestore()`). Ce gestionnaire enregistre également la `Resource` dans le `Context` global géré par l’environnement d’exécution.
**Note**
Lorsque Lambda crée un instantané, votre code d’initialisation peut s’exécuter jusqu’à 15 minutes. Le délai d’attente est de 130 secondes ou le [délai d’expiration de la fonction configurée](configuration-timeout.md) (900 secondes au maximum), la valeur la plus élevée étant retenue. Vos hooks d’exécution `beforeCheckpoint()` sont comptabilisés dans le délai d’attente du code d’initialisation. Lorsque Lambda restaure un instantané, l’exécution (JVM) doit se charger et les hooks d’exécution `afterRestore()` doivent se terminer dans le délai imparti (10 secondes). Sinon, vous obtiendrez un 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");
```
`Context` maintient uniquement une [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) à l’objet enregistré. Si une [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) est récupérée par le récupérateur de mémoire, les hooks d’exécution ne s’exécutent pas. Votre code doit maintenir une référence forte à la `Resource` pour garantir l’exécution du hook d’exécution.
Voici deux exemples de modèles à éviter :
**Example – Objet sans référence forte**
```
Core.getGlobalContext().register( new MyResource() );
```
**Example – Objets de classes anonymes**
```
Core.getGlobalContext().register( new Resource() {
@Override
public void afterRestore(Context context) throws Exception {
// ...
}
@Override
public void beforeCheckpoint(Context context) throws Exception {
// ...
}
} );
```
Au lieu de cela, maintenez une référence forte. Dans l’exemple suivant, la ressource enregistrée n’est pas récupérée par le récupérateur de mémoire et les hooks d’exécution s’exécutent de manière cohérente.
**Example – Objet avec une référence forte**
```
Resource myResource = new MyResource(); // This reference must be maintained to prevent the registered resource from being garbage collected
Core.getGlobalContext().register( myResource );
```
# Hooks d’exécution Lambda SnapStart pour Python
Vous pouvez utiliser des hooks d’exécution pour implémenter du code avant que Lambda ne crée un instantané ou après que Lambda ait repris une fonction à partir d’un instantané. Les hooks d’exécution Python sont disponibles dans le cadre de la [bibliothèque Snapshot Restore for Python](https://pypi.org/project/snapshot-restore-py/) open source, qui est incluse dans les environnements d’exécution gérés par Python. Cette bibliothèque fournit deux décorateurs que vous pouvez utiliser pour définir vos hooks d’exécution :
+ `@register_before_snapshot` : pour les fonctions que vous souhaitez exécuter avant que Lambda ne crée un instantané.
+ `@register_after_restore` : pour les fonctions que vous souhaitez exécuter lorsque Lambda reprend une fonction à partir d’un instantané.
Vous pouvez également utiliser les méthodes suivantes afin d’enregistrer des fonctions pouvant être appelées pour des hooks d’exécution :
+ `register_before_snapshot(func, *args, **kwargs)`
+ `register_after_restore(func, *args, **kwargs)`
## Enregistrement et exécution du hook d’exécution
L’ordre dans lequel Lambda exécute vos hooks d’exécution est déterminé par l’ordre d’enregistrement :
+ Avant l’instantané : exécutés dans l’ordre inverse de l’enregistrement
+ Après l’instantané : exécutés dans l’ordre d’enregistrement
L’ordre d’enregistrement des hooks d’exécution dépend de la façon dont vous définissez les hooks. Lorsque vous utilisez des décorateurs (`@register_before_snapshot` et `@register_after_restore`), l’ordre d’enregistrement suit l’ordre d’importation, de définition ou d’exécution dans votre code. Si vous avez besoin de plus de contrôle sur l’ordre d’enregistrement, utilisez les méthodes `register_before_snapshot()` et `register_after_restore()` au lieu des décorateurs.
Assurez-vous que tous les hooks enregistrés sont correctement importés et inclus dans le code de votre fonction. Si vous enregistrez les hooks d’exécution dans un fichier ou un module distinct, vous devez vous assurer que le module est importé, soit directement, soit dans le cadre d’un package plus large, dans le fichier de gestionnaire de votre fonction. Si le fichier ou le module n’est pas importé dans le gestionnaire de fonctions, Lambda ignore les hooks d’exécution.
**Note**
Lorsque Lambda crée un instantané, votre code d’initialisation peut s’exécuter jusqu’à 15 minutes. Le délai d’attente est de 130 secondes ou le [délai d’expiration de la fonction configurée](configuration-timeout.md) (900 secondes au maximum), la valeur la plus élevée étant retenue. Vos hooks d’exécution `@register_before_snapshot` sont comptabilisés dans le délai d’attente du code d’initialisation. Lorsque Lambda restaure un instantané, l’exécution doit se charger et les hooks d’exécution `@register_after_restore` doivent se terminer dans le délai imparti (10 secondes). Sinon, vous obtiendrez une SnapStartTimeoutException.
## Exemple
L’exemple de gestionnaire suivant montre comment exécuter le code avant le point de contrôle (`@register_before_snapshot`) et après la restauration (`@register_after_restore`).
```
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
```
Pour plus d’exemples, consultez [Snapshot Restore pour Python](https://github.com/aws/snapshot-restore-py/tree/main/examples) dans le référentiel GitHub AWS.
# Hooks d’exécution Lambda SnapStart pour .NET
Vous pouvez utiliser des hooks d’exécution pour implémenter du code avant que Lambda ne crée un instantané ou après que Lambda ait repris une fonction à partir d’un instantané. Les hooks d’exécution .NET sont disponibles dans le cadre du package [Amazon.Lambda.Core](https://www.nuget.org/packages/Amazon.Lambda.Core) (version 2.5.0 ou ultérieure). Cette bibliothèque fournit deux méthodes que vous pouvez utiliser pour définir vos hooks d’exécution :
+ `RegisterBeforeSnapshot()` : code à exécuter avant la création de l’instantané
+ `RegisterAfterSnapshot()` : code à exécuter après la reprise d’une fonction à partir d’un instantané
**Note**
Si vous utilisez le [cadre Lambda Annotations pour .NET](csharp-handler.md#csharp-handler-annotations), passez à [Amazon.Lambda.Annotations](https://www.nuget.org/packages/Amazon.Lambda.Annotations) version 1.6.0 ou ultérieure pour garantir la compatibilité avec SnapStart.
## Enregistrement et exécution du hook d’exécution
Enregistrez vos hooks dans votre code d’initialisation. Tenez compte des directives suivantes en fonction du [modèle d’exécution](csharp-handler.md#csharp-handler-setup) de votre fonction Lambda :
+ Pour l’[approche de l’assemblage exécutable](csharp-handler.md#csharp-executable-assembly-handlers), enregistrez vos hooks avant de démarrer l’amorçage Lambda avec `RunAsync`.
+ Pour l’[approche de la bibliothèque de classes](csharp-handler.md#csharp-class-library-handlers), enregistrez vos hooks dans le constructeur de classe du gestionnaire.
+ Pour les [applications ASP.NET Core](csharp-package-asp.md), enregistrez vos hooks avant d’appeler la méthode `WebApplications.Run`.
Pour enregistrer des hooks d’exécution pour SnapStart dans .NET, utilisez les méthodes suivantes :
```
Amazon.Lambda.Core.SnapshotRestore.RegisterBeforeSnapshot(BeforeCheckpoint);
Amazon.Lambda.Core.SnapshotRestore.RegisterAfterRestore(AfterCheckpoint);
```
Lorsque plusieurs types de hooks sont enregistrés, l’ordre dans lequel Lambda exécute vos hooks d’exécution est déterminé par l’ordre d’enregistrement :
+ `RegisterBeforeSnapshot()` : exécutés dans l’ordre inverse de l’enregistrement
+ `RegisterAfterSnapshot()` : exécutés dans l’ordre d’enregistrement
**Note**
Lorsque Lambda crée un instantané, votre code d’initialisation peut s’exécuter jusqu’à 15 minutes. Le délai d’attente est de 130 secondes ou le [délai d’expiration de la fonction configurée](configuration-timeout.md) (900 secondes au maximum), la valeur la plus élevée étant retenue. Vos hooks d’exécution `RegisterBeforeSnapshot()` sont comptabilisés dans le délai d’attente du code d’initialisation. Lorsque Lambda restaure un instantané, l’exécution doit se charger et les hooks d’exécution `RegisterAfterSnapshot()` doivent se terminer dans le délai imparti (10 secondes). Sinon, vous obtiendrez une SnapStartTimeoutException.
## Exemple
L’exemple de fonction suivant montre comment exécuter le code avant le point de contrôle (`RegisterBeforeSnapshot`) et après la restauration (`RegisterAfterRestore`).
```
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
};
}
}
```