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). Pour un exemple d'utilisation de CRa C avec une application de référence, consultez le référentiel CRaC sur GitHub. CRaC utilise trois éléments principaux :

Pour plus d'informations sur Context etResource, consultez Package org.crac dans la CRa documentation C.

Suivez les étapes suivantes pour implémenter des hooks d’exécution avec le package 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.

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.

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

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.

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.

...
  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<? extends Resource> context)
        throws Exception {
      System.out.println("Before checkpoint");
    }
    @Override
    public void afterRestore(org.crac.Context<? extends Resource> context)
        throws Exception {
      System.out.println("After restore");

Context maintient uniquement une WeakReference à l’objet enregistré. Si une Resource 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 :

Core.getGlobalContext().register( new MyResource() );

Core.getGlobalContext().register( new Resource() {
   
   @Override
   public void afterRestore(Context<? extends Resource> context) throws Exception {
    // ...
   }
   
   @Override
   public void beforeCheckpoint(Context<? extends Resource> 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.

Resource myResource = new MyResource(); // This reference must be maintained to prevent the registered resource from being garbage collected
Core.getGlobalContext().register( myResource );