Implémenter le code avant ou après les captures d'écran des 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 disponibles dans le cadre du projet open source Coordinated Restore at Checkpoint (CRaC). CRaC est en cours de développement pour l'Open Java Development Kit (OpenJDK). Pour un exemple d'utilisation de CRac 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 et Resource, consultez Package org.crac dans la documentation de CRaC.

Suivez les étapes suivantes pour implémenter des hooks d'exécution avec le package org.crac. L'environnement d'exécution Lambda contient une implémentation de contexte CRaC personnalisée qui appelle vos hooks d'exécution avant le point de contrôle et après la restauration.

É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 plus d’informations, consultez Définir le gestionnaire de fonctions Lambda en 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 );