# Implemente el código antes o después de las instantáneas de la función de Lambda
Puede utilizar enlaces de tiempo de ejecución para implementar el código antes de que Lambda cree una instantánea o después de que Lambda restaure una función desde una instantánea. Los enlaces de tiempo de ejecución son útiles para una variedad de propósitos, tales como:
+ **Limpieza e inicialización:** antes de crear una instantánea, puede utilizar un enlace de tiempo de ejecución para realizar operaciones de limpieza o liberación de recursos. Una vez restaurada una instantánea, puede usar un enlace de tiempo de ejecución para reinicializar cualquier recurso o estado que no se haya capturado en la instantánea.
+ **Configuración dinámica:** puede usar enlaces de tiempo de ejecución para actualizar dinámicamente la configuración u otros metadatos antes de crear una instantánea o después de restaurarla. Esto puede resultar útil si la función necesita adaptarse a los cambios en el entorno de tiempo de ejecución.
+ **Integraciones externas:** puede usar enlaces de tiempo de ejecución para integrarse con servicios o sistemas externos, como enviar notificaciones o actualizar el estado externo, como parte del proceso de comprobación y restauración.
+ **Ajuste del rendimiento:** puede usar enlaces de tiempo de ejecución para afinar la secuencia de inicio de la función, por ejemplo, al precargar las dependencias. Para obtener más información, consulte [Ajuste del rendimiento](snapstart-best-practices.md#snapstart-tuning).
En las siguientes páginas, se explica cómo implementar los enlaces de tiempo de ejecución para el tiempo de ejecución que prefiera.
**Topics**
+ [Java](snapstart-runtime-hooks-java.md)
+ [Python](snapstart-runtime-hooks-python.md)
+ [.NET](snapstart-runtime-hooks-dotnet.md)
# Enlaces de tiempo de ejecución de Lambda SnapStart para Java
Puede utilizar enlaces de tiempo de ejecución para implementar el código antes de que Lambda cree una instantánea o después de que Lambda restaure una función desde una instantánea. Los enlaces de tiempo de ejecución están disponibles como parte del proyecto Coordinated Restore at Checkpoint (CRaC) de código abierto. El CRaC está en desarrollo para el [Open Java Development Kit (OpenJDK)](https://wiki.openjdk.org/display/crac). Para ver un ejemplo de cómo utilizar CRaC con una aplicación de referencia, visite el repositorio de [CRaC](https://github.com/CRaC/docs/blob/master/STEP-BY-STEP.md) en GitHub. CRaC utiliza tres elementos principales:
+ `Resource`: una interfaz con dos métodos, `beforeCheckpoint()` y `afterRestore()`. Utilice estos métodos para implementar el código que desea ejecutar antes de una instantánea y después de una restauración.
+ `Context `: para recibir notificaciones de puntos de comprobación y restauraciones, debe haber un `Resource` con un `Context`.
+ `Core`: el servicio de coordinación, que proporciona el `Context` global predeterminado mediante el método estático `Core.getGlobalContext()`.
Para obtener más información sobre `Context` y `Resource`, consulte [Package org.crac](https://javadoc.io/doc/io.github.crac/org-crac/latest/index.html) en la documentación de CRaC.
Siga los siguientes pasos para implementar enlaces de tiempo de ejecución con [Package org.crac](https://github.com/CRaC/org.crac). El tiempo de ejecución de Lambda contiene una implementación contextual de CRaC personalizada que invoca los enlaces de tiempo de ejecución antes de realizar comprobaciones y después de restaurarlos.
## Registro y ejecución de enlaces en tiempo de ejecución
El orden en que Lambda ejecuta los enlaces de tiempo de ejecución viene determinado por el orden de registro. El orden de registro sigue el orden de importación, definición o ejecución del código.
+ `beforeCheckpoint()`: se ejecuta en el orden inverso al de registro
+ `afterRestore()`: se ejecuta en el orden del registro
Asegúrese de que todos los enlaces registrados se hayan importado e incluido correctamente en el código de la función. Si registra los enlaces de tiempo de ejecución en un archivo o módulo independiente, debe asegurarse de que el módulo se importe, directamente o como parte de un paquete más grande, al archivo controlador de la función. Si el archivo o el módulo no se importa en el controlador de funciones, Lambda ignora los enlaces del tiempo de ejecución.
**nota**
Cuando Lambda crea una instantánea, el código de inicialización puede ejecutarse durante un máximo de 15 minutos. El límite de tiempo es de 130 segundos o el [tiempo de espera de la función configurado](configuration-timeout.md) (máximo de 900 segundos), lo que sea mayor. Los enlaces en tiempo de ejecución `beforeCheckpoint()` cuentan para el límite de tiempo del código de inicialización. Cuando Lambda restaura una instantánea, el tiempo de ejecución debe cargarse y los enlaces de tiempo de ejecución `afterRestore()` deben completarse antes de que transcurra el tiempo de espera (10 segundos). De lo contrario, obtendrá una excepción SnapStartTimeoutException.
## Paso 1: Actualizar la configuración de compilación
Agregue la dependencia `org.crac` a la configuración de compilación. El siguiente ejemplo utiliza Gradle. Para ver ejemplos de otros sistemas de compilación, consulte la [documentación de 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'
}
```
## Paso 2: Actualizar del controlador de Lambda
El *controlador* de la función de Lambda es el método del código de la función que procesa eventos. Cuando se invoca una función, Lambda ejecuta el método del controlador. La función se ejecuta hasta que el controlador devuelve una respuesta, se cierra o se agota el tiempo de espera.
Para obtener más información, consulte [Definir el controlador de las funciones de Lambda en Java](java-handler.md).
El siguiente controlador de ejemplo muestra cómo ejecutar el código antes de comprobar (`beforeCheckpoint()`) y después de restaurarlo (`afterRestore()`). Este controlador también registra el `Resource` al `Context` global administrado en tiempo de ejecución.
**nota**
Cuando Lambda crea una instantánea, el código de inicialización puede ejecutarse durante un máximo de 15 minutos. El límite de tiempo es de 130 segundos o el [tiempo de espera de la función configurado](configuration-timeout.md) (máximo de 900 segundos), lo que sea mayor. Los enlaces en tiempo de ejecución `beforeCheckpoint()` cuentan para el límite de tiempo del código de inicialización. Cuando Lambda restaura una instantánea, el tiempo de ejecución (JVM) debe cargarse y los enlaces de tiempo de ejecución `afterRestore()` deben completarse antes de que transcurra el tiempo de espera (10 segundos). De lo contrario, obtendrá una excepción 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` mantiene solo una [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) para el objeto registrado. Si un [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) es una recopilación de elementos no utilizados, los enlaces de tiempo de ejecución no se ejecutan. Su código debe mantener una referencia segura para el `Resource` para garantizar que se ejecute el enlace de tiempo de ejecución.
Estos son dos ejemplos de patrones que se deben evitar:
**Example — Objeto sin una referencia sólida**
```
Core.getGlobalContext().register( new MyResource() );
```
**Example — Objetos de clases anónimas**
```
Core.getGlobalContext().register( new Resource() {
@Override
public void afterRestore(Context context) throws Exception {
// ...
}
@Override
public void beforeCheckpoint(Context context) throws Exception {
// ...
}
} );
```
En su lugar, mantenga una referencia sólida. En el siguiente ejemplo, el recurso registrado no es una recopilación de elementos no utilizados y los enlaces de tiempo de ejecución se ejecutan de manera uniforme.
**Example — Objeto con una referencia sólida**
```
Resource myResource = new MyResource(); // This reference must be maintained to prevent the registered resource from being garbage collected
Core.getGlobalContext().register( myResource );
```
# Enlaces de tiempo de ejecución de Lambda SnapStart para Python
Puede utilizar enlaces de tiempo de ejecución para implementar el código antes de que Lambda cree una instantánea o después de que Lambda restaure una función desde una instantánea. Los enlaces de tiempo de ejecución de Python están disponibles como parte de la [biblioteca Snapshot Restore for Python](https://pypi.org/project/snapshot-restore-py/) de código abierto que se incluye en los tiempos de ejecución administrados por Python. Esta biblioteca proporciona dos decoradores que puede usar para definir sus enlaces de tiempo de ejecución:
+ `@register_before_snapshot`: para las funciones que desee ejecutar antes de que Lambda cree una instantánea.
+ `@register_after_restore`: para las funciones que desee ejecutar cuando Lambda reanude una función desde una instantánea.
Alternativamente, puede utilizar los siguientes métodos para registrar los elementos invocables para los enlaces de tiempo de ejecución:
+ `register_before_snapshot(func, *args, **kwargs)`
+ `register_after_restore(func, *args, **kwargs)`
## Registro y ejecución de enlaces en tiempo de ejecución
El orden en que Lambda ejecuta los enlaces de tiempo de ejecución viene determinado por el orden de registro:
+ Antes de la instantánea: se ejecuta en el orden inverso al de registro
+ Después de la instantánea: se ejecuta en el orden de registro
El orden de registro de los enlaces de tiempo de ejecución depende de cómo se definan los enlaces. Cuando se utilizan decoradores (`@register_before_snapshot` y `@register_after_restore`), el orden de registro sigue el orden de importación, definición o ejecución del código. Si necesita tener más control sobre el orden de registro, utilice los métodos `register_before_snapshot()` y `register_after_restore()` en lugar de los decoradores.
Asegúrese de que todos los enlaces registrados se hayan importado e incluido correctamente en el código de la función. Si registra los enlaces de tiempo de ejecución en un archivo o módulo independiente, debe asegurarse de que el módulo se importe, directamente o como parte de un paquete más grande, al archivo controlador de la función. Si el archivo o el módulo no se importa en el controlador de funciones, Lambda ignora los enlaces del tiempo de ejecución.
**nota**
Cuando Lambda crea una instantánea, el código de inicialización puede ejecutarse durante un máximo de 15 minutos. El límite de tiempo es de 130 segundos o el [tiempo de espera de la función configurado](configuration-timeout.md) (máximo de 900 segundos), lo que sea mayor. Los enlaces en tiempo de ejecución `@register_before_snapshot` cuentan para el límite de tiempo del código de inicialización. Cuando Lambda restaura una instantánea, el tiempo de ejecución debe cargarse y los enlaces de tiempo de ejecución `@register_after_restore` deben completarse antes de que transcurra el tiempo de espera (10 segundos). De lo contrario, obtendrá una excepción SnapStartTimeoutException.
## Ejemplo
El siguiente controlador de ejemplo muestra cómo ejecutar el código antes de comprobar (`@register_before_snapshot`) y después de restaurarlo (`@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
```
Para ver más ejemplos, consulte [Snapshot Restore for Python](https://github.com/aws/snapshot-restore-py/tree/main/examples) en el repositorio de GitHub de AWS.
# Enlaces de tiempo de ejecución de Lambda SnapStart para .NET
Puede utilizar enlaces de tiempo de ejecución para implementar el código antes de que Lambda cree una instantánea o después de que Lambda restaure una función desde una instantánea. Los enlaces de tiempo de ejecución de .NET están disponibles como parte del paquete [Amazon.Lambda.Core](https://www.nuget.org/packages/Amazon.Lambda.Core) (versión 2.5.0 o posterior). Esta biblioteca brinda dos métodos que puede utilizar para definir sus enlaces de tiempo de ejecución:
+ `RegisterBeforeSnapshot()`: código para ejecutar antes de la creación de la instantánea
+ `RegisterAfterSnapshot()`: código para ejecutar después de reanudar una función a partir de una instantánea
**nota**
Si utiliza el [marco de Lambda Annotations para .NET](csharp-handler.md#csharp-handler-annotations), actualice a [Amazon.Lambda.Annotations](https://www.nuget.org/packages/Amazon.Lambda.Annotations) versión 1.6.0 o posterior para garantizar la compatibilidad con SnapStart.
## Registro y ejecución de enlaces en tiempo de ejecución
Registre sus enlaces en el código de inicialización. Tenga en cuenta las siguientes pautas según el modelo de [ejecución](csharp-handler.md#csharp-handler-setup) de la función de Lambda:
+ Para el [enfoque de ensamblaje ejecutable](csharp-handler.md#csharp-executable-assembly-handlers), registre los enlaces antes de iniciar el arranque de Lambda con `RunAsync`.
+ Para el [enfoque de biblioteca de clase](csharp-handler.md#csharp-class-library-handlers), registre sus enlaces en el constructor de clase del controlador.
+ En el [caso de las aplicaciones ASP.NET Core](csharp-package-asp.md), registre los enlaces antes de llamar al método `WebApplications.Run`.
Para registrar los enlaces en tiempo de ejecución para SnapStart en .NET, utilice los métodos siguientes:
```
Amazon.Lambda.Core.SnapshotRestore.RegisterBeforeSnapshot(BeforeCheckpoint);
Amazon.Lambda.Core.SnapshotRestore.RegisterAfterRestore(AfterCheckpoint);
```
Cuando se registran varios tipos de enlaces, el orden en el que Lambda ejecuta los enlaces en tiempo de ejecución viene determinado por el orden de registro:
+ `RegisterBeforeSnapshot()`: se ejecuta en el orden inverso al de registro
+ `RegisterAfterSnapshot()`: se ejecuta en el orden del registro
**nota**
Cuando Lambda crea una instantánea, el código de inicialización puede ejecutarse durante un máximo de 15 minutos. El límite de tiempo es de 130 segundos o el [tiempo de espera de la función configurado](configuration-timeout.md) (máximo de 900 segundos), lo que sea mayor. Los enlaces en tiempo de ejecución `RegisterBeforeSnapshot()` cuentan para el límite de tiempo del código de inicialización. Cuando Lambda restaura una instantánea, el tiempo de ejecución debe cargarse y los enlaces de tiempo de ejecución `RegisterAfterSnapshot()` deben completarse antes de que transcurra el tiempo de espera (10 segundos). De lo contrario, obtendrá una excepción SnapStartTimeoutException.
## Ejemplo
La siguiente función de ejemplo muestra cómo ejecutar el código antes de comprobar (`RegisterBeforeSnapshot`) y después de restaurarlo (`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
};
}
}
```