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 :

• 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 <R extends Resource> – 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 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.

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 (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<? 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 :

Exemple – Objet sans référence forte

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

Exemple – Objets de classes anonymes

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.

Exemple – 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 );