Implementa il codice prima o dopo le istantanee della funzione Lambda

Gli hook di runtime possono essere utilizzati per implementare il codice prima che Lambda crei uno snapshot o dopo che ha ripristinato una funzione da uno snapshot. Gli hook di runtime sono disponibili come parte del progetto open source Coordinated Restore at Checkpoint (CRaC). CRaC è in fase sviluppo per l'Open Java Development Kit (OpenJDK). Per un esempio di come usare cRac con un'applicazione di riferimento, consulta il repository cRac su. GitHub Il CRaC utilizza tre elementi principali:

Per ulteriori informazioni su Context e Resource, consulta Pacchetto org.crac nella documentazione di CRaC.

Completa le seguenti operazioni per implementare gli hook di runtime con il pacchetto org.crac. Il runtime Lambda contiene un'implementazione del contesto CRaC personalizzata che chiama gli hook di runtime prima del checkpoint e dopo il ripristino.

Fase 1: aggiornamento della configurazione di build

Aggiungi la dipendenza org.crac alla configurazione della build. Nell'esempio seguente viene utilizzato Gradle. Per esempi di altri sistemi di compilazione, consulta la documentazione di 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'
}

Fase 2: aggiornamento del gestore Lambda

Il gestore di funzioni Lambda è il metodo nel codice della funzione che elabora gli eventi. Quando viene richiamata la funzione, Lambda esegue il metodo del gestore. La funzione viene eseguita fino a quando il gestore non restituisce una risposta, termina o scade.

Per ulteriori informazioni, consulta Definisci il gestore di funzioni Lambda in Java.

Il seguente gestore di esempio mostra come eseguire il codice prima del checkpoint (beforeCheckpoint()) e dopo il ripristino (afterRestore()). Questo gestore registra anche la Resource nel Context gestito dal runtime.

...
  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 mantiene solo un WeakReference all'oggetto registrato. Se per una Resource viene eseguita la rimozione di oggetti inutili (garbage collection), gli hook di runtime non vengono eseguiti. Il codice deve mantenere un forte riferimento alla Resource per garantire l'esecuzione dell'hook di runtime.

Ecco due esempi di modelli da evitare:

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 {
    // ...
   }

} );

Invece, mantieni un riferimento forte. Nell'esempio seguente, per la risorsa registrata non viene eseguita la rimozione di oggetti inutili (garbage collection) e gli hook di runtime vengono eseguiti in modo coerente.

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