# Mejora del rendimiento de inicio con Lambda SnapStart Lambda SnapStart puede ofrecer un rendimiento de inicio en menos de un segundo, normalmente sin cambios en el código de la función. SnapStart facilita la creación de aplicaciones con alta capacidad de respuesta y escalables sin aprovisionar recursos ni implementar optimizaciones de rendimiento complejas. El factor que más contribuye a la latencia de inicio (a menudo denominado tiempo de inicio en frío) es el tiempo que Lambda dedica a inicializar la función, que incluye cargar el código de la función, iniciar el tiempo de ejecución e inicializar el código de la función. Con SnapStart, Lambda inicializa la función al publicar una versión de la función. Lambda toma una instantánea de [Firecracker microVM](https://aws.amazon.com/blogs/opensource/firecracker-open-source-secure-fast-microvm-serverless/) del estado de la memoria y el disco correspondientes al [entorno de ejecución](lambda-runtime-environment.md) inicializado, cifra la instantánea y la almacena en caché de manera inteligente para optimizar la latencia de recuperación. Para garantizar la resiliencia, Lambda mantiene varias copias de cada instantánea. Lambda aplica automáticamente parches a las instantáneas y sus copias con las últimas actualizaciones de tiempo de ejecución y seguridad. Al invocar la versión de la función por primera vez y a medida que las invocaciones escalan verticalmente, Lambda reanuda los nuevos entornos de ejecución a partir de la instantánea almacenada en caché, en lugar de inicializarlos desde cero, lo que mejora la latencia de inicio. **importante** Si sus aplicaciones dependen de la singularidad del estado, debe evaluar el código de su función y comprobar que es resistente a las operaciones de instantáneas. Para obtener más información, consulte [Control de la exclusividad con Lambda SnapStart](snapstart-uniqueness.md). **Topics** + [ ## Cuándo usar SnapStart ](#snapstart-use-cases) + [ ## Características y limitaciones compatibles ](#snapstart-runtimes) + [ ## Regiones admitidas ](#snapstart-supported-regions) + [ ## Consideraciones sobre compatibilidad ](#snapstart-compatibility) + [ ## Precios de SnapStart ](#snapstart-pricing) + [ # Activación y administración de Lambda SnapStart ](snapstart-activate.md) + [ # Control de la exclusividad con Lambda SnapStart ](snapstart-uniqueness.md) + [ # Implemente el código antes o después de las instantáneas de la función de Lambda ](snapstart-runtime-hooks.md) + [ # Monitoreo para Lambda SnapStart ](snapstart-monitoring.md) + [ # Modelo de seguridad para Lambda SnapStart ](snapstart-security.md) + [ # Maximice el rendimiento de Lambda SnapStart ](snapstart-best-practices.md) + [ # Solución de problemas de errores de SnapStart para funciones de Lambda ](snapstart-troubleshooting.md) ## Cuándo usar SnapStart Lambda SnapStart está diseñado para abordar la variabilidad de latencia que introduce el código de inicialización único, como la carga de estructuras o dependencias de módulos. En ocasiones, estas operaciones pueden tardar varios segundos en completarse durante la invocación inicial. Utilice SnapStart para reducir esta latencia de varios segundos a tan solo menos de un segundo, en escenarios óptimos. SnapStart funciona mejor cuando se usa con invocaciones de funciones a escala. Es posible que las funciones que se invocan con poca frecuencia no experimenten las mismas mejoras de rendimiento. SnapStart es particularmente útil para dos tipos principales de aplicaciones: + **Flujos de usuarios y API sensibles a la latencia:** las funciones que forman parte de los puntos de conexión críticos de las API o de los flujos orientados al usuario pueden beneficiarse de la reducción de la latencia y la mejora de los tiempos de respuesta de SnapStart. + **Flujos de trabajo de procesamiento de datos sensibles a la latencia:** los flujos de trabajo de procesamiento de datos con límite de tiempo que utilizan funciones de Lambda pueden lograr un mejor rendimiento al reducir la latencia de inicialización de funciones atípicas. [La simultaneidad aprovisionada](provisioned-concurrency.md) mantiene las funciones inicializadas y listas para responder en cuestión de milisegundos de dos dígitos. Utilice la simultaneidad aprovisionada si su aplicación tiene requisitos estrictos de latencia para los inicios en frío y no los puede abordar de forma adecuada con SnapStart. ## Características y limitaciones compatibles SnapStart está disponible para los siguientes tiempos de ejecución [administrados por Lambda](lambda-runtimes.md): + Java 11 y versiones posteriores + Python 3.12 y posteriores + .NET 8 y versiones posteriores. 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. No se admiten otros tiempos de ejecución administrados (como `nodejs24.x` y `ruby3.4`), [Tiempos de ejecución exclusivos del sistema operativo](runtimes-provided.md), ni [imágenes de contenedor](images-create.md) SnapStart no admite la [simultaneidad aprovisionada](provisioned-concurrency.md), [Amazon Elastic File System (Amazon EFS)](https://docs.aws.amazon.com/efs/latest/ug/accessing-fs.html), ni almacenamiento efímero de más de 512 MB. **nota** Puede usar SnapStart solo en las [versiones de funciones publicadas](configuration-versions.md#configuration-versions-config) y en los [alias](configuration-aliases.md) que apunten a versiones. No puede usar SnapStart en la versión no publicada de una función (\$1LATEST). ## Regiones admitidas Lambda SnapStart está disponible en todas las [regiones comerciales](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#region), excepto en Asia-Pacífico (Taipéi). ## Consideraciones sobre compatibilidad Con SnapStart, Lambda utiliza una única instantánea como estado inicial para varios entornos de ejecución. Si la función utiliza alguno de los siguientes factores durante la [fase de inicialización](lambda-runtime-environment.md#runtimes-lifecycle-ib), es posible que deba realizar algunos cambios antes de usar SnapStart: **Singularidad** Si el código de inicialización genera contenido único que se incluye en la instantánea, es posible que el contenido no lo sea cuando se reutilice en los entornos de ejecución. Para mantener la exclusividad al utilizar SnapStart, debe generar contenido único después de la inicialización. Esto incluye ID y secretos únicos y entropía que se utiliza para generar pseudoaleatoriedad. Para aprender a restaurar la singularidad, consulte [Control de la exclusividad con Lambda SnapStart](snapstart-uniqueness.md). **Conexiones de red** El estado de las conexiones que establece la función durante la fase de inicialización no está garantizado cuando Lambda vuelve a activar la función a partir de una instantánea. Valide el estado de sus conexiones de red y vuelva a establecerlas según sean necesarias. En la mayoría de los casos, las conexiones de red que establece un SDK de AWS se reanudan automáticamente. Para otras conexiones, consulte las [prácticas recomendadas](snapstart-best-practices.md). **Datos temporales** Algunas funciones descargan o inicializan datos efímeros, como credenciales temporales o marcas temporales almacenadas en caché, durante la fase de inicialización. Actualice los datos efímeros en el controlador de funciones antes de usarlos, incluso cuando no utilice SnapStart. ## Precios de SnapStart **nota** En el caso de los tiempos de ejecución administrados por Java, no se aplica ningún costo adicional por usar SnapStart. Se le cobrará en función del número de solicitudes de tus funciones, del tiempo que el código tarda en ejecutarse y de la memoria configurada para la función. El costo de usar SnapStart incluye lo siguiente: + **Almacenamiento en caché:** por cada versión de función que publique con SnapStart habilitado, pagará el costo del almacenamiento en caché y el mantenimiento de la instantánea. El precio depende de la cantidad de [memoria](configuration-memory.md) que asigne a la función. Se cobrará por un mínimo de 3 horas. Aún incurrirá en cargos mientras la función permanezca [activa](snapstart-activate.md#snapstart-active). Utilice la acción de la API [ListVersionsByFunction](https://docs.aws.amazon.com/lambda/latest/api/API_ListVersionsByFunction.html) para identificar las versiones de las funciones y, a continuación, utilice [DeleteFunction](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteFunction.html) para eliminar las versiones no utilizadas. Para eliminar automáticamente las versiones de funciones no utilizadas, consulte el patrón de [limpieza de versiones de Lambda](https://serverlessland.com/workflows/step-functions-lambda-version-cleanup) en Land sin servidor. + **Restauración:** cada vez que se restaure una instancia de función a partir de una instantánea, paga un cargo de restauración. El precio depende de la cantidad de memoria que asigne a la función. Como ocurre con todas las funciones de Lambda, los cargos por duración se aplican al código que se ejecuta en el controlador de funciones. Para las funciones de SnapStart, también se aplican cargos por duración al código de inicialización declarado fuera del controlador, al tiempo que tarda en cargarse el entorno de ejecución y a cualquier código que se ejecute en un [enlace del tiempo de ejecución](snapstart-runtime-hooks.md). La duración se calcula desde el momento en que el código comienza a ejecutarse hasta que devuelve resultados o finaliza de algún otro modo, y se redondea al milisegundo más cercano. Lambda mantiene copias en caché de la instantánea para garantizar su resiliencia y les aplica automáticamente las actualizaciones de software, como las actualizaciones de tiempo de ejecución y los parches de seguridad. Se aplican cargos cada vez que Lambda vuelva a ejecutar su código de inicialización para aplicar actualizaciones de software. Para obtener más información sobre el costo de usar SnapStart, consulte [Precios de AWS Lambda](https://aws.amazon.com/lambda/pricing/#SnapStart_Pricing). # Activación y administración de Lambda SnapStart Para utilizar SnapStart, active SnapStart en una función de Lambda nueva o existente. A continuación, publique e invoque una versión de la función. **Topics** + [ ## Activación de SnapStart (consola) ](#snapshot-console) + [ ## Activación de SnapStart (AWS CLI) ](#snapshot-cli) + [ ## Activación de SnapStart (API) ](#snapshot-api) + [ ## Lambda SnapStart y estados de la función ](#snapstart-function-states) + [ ## Actualización de una instantánea ](#update-snapshot) + [ ## Uso de SnapStart con AWS SDK ](#snapstart-credentials) + [ ## Uso de SnapStart con CloudFormation, AWS SAM y AWS CDK ](#snapstart-cfn-sam) + [ ## Eliminación de instantáneas ](#snapshot-delete) ## Activación de SnapStart (consola) **Para activar SnapStart para una función** 1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda. 1. Elija el nombre de una función. 1. Elija **Configuration** (Configuración) y, a continuación, **General configuration** (Configuración general). 1. En el panel de **General configuration** (Configuración general), elija **Edit** (Editar). 1. En la página **Edit basic settings** (Editar la configuración básica), para **SnapStart**, seleccione **Published versions** (Versiones publicadas). 1. Seleccione **Save** (Guardar). 1. [Publique una versión de la función](configuration-versions.md#configuration-versions-config). Lambda inicializa el código, crea una instantánea del entorno de ejecución inicializado y, a continuación, almacena la instantánea en caché para acceder a ella con baja latencia. 1. [Invoque la versión de la función](configuration-versions.md#versioning-versions-using). ## Activación de SnapStart (AWS CLI) **Para activar SnapStart para una función existente** 1. Actualice la configuración de la función ejecutando el comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) con la opción **--snap-start**. ``` aws lambda update-function-configuration \ --function-name my-function \ --snap-start ApplyOn=PublishedVersions ``` 1. Utilice el comando [publish-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-version.html) para publicar una versión de la función. ``` aws lambda publish-version \ --function-name my-function ``` 1. Confirme que SnapStart está activado para la versión de la función; para ello, ejecute el comando [get-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/get-function-configuration.html) y especifique el número de versión. El siguiente ejemplo especifica la versión 1. ``` aws lambda get-function-configuration \ --function-name my-function:1 ``` Si la respuesta muestra que [OptimizationStatus](https://docs.aws.amazon.com/lambda/latest/api/API_SnapStartResponse.html) es `On` y [Estado](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html#lambda-GetFunctionConfiguration-response-State) es `Active`, SnapStart se activa y hay una instantánea disponible para la versión de la función especificada. ``` "SnapStart": { "ApplyOn": "PublishedVersions", "OptimizationStatus": "On" }, "State": "Active", ``` 1. Para invocar la versión de la función, ejecute el comando [invoke](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/invoke.html) y especifique la versión. El siguiente ejemplo invoca la versión 1. ``` aws lambda invoke \ --cli-binary-format raw-in-base64-out \ --function-name my-function:1 \ --payload '{ "name": "Bob" }' \ response.json ``` La opción **cli-binary-format** es obligatoria si va a utilizar la versión 2 de la AWS CLI. Para que esta sea la configuración predeterminada, ejecute `aws configure set cli-binary-format raw-in-base64-out`. Para obtener más información, consulte [Opciones de la línea de comandos globales compatibles con AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) en la *Guía del usuario de la AWS Command Line Interface versión 2*. **Para activar SnapStart cuando crea una nueva función** 1. Ejecute el comando [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) para crear una función con la opción **--snap-start**. Para **--role**, especifique el nombre de recurso de Amazon (ARN) del [rol de ejecución](lambda-intro-execution-role.md). ``` aws lambda create-function \ --function-name my-function \ --runtime "java25" \ --zip-file fileb://my-function.zip \ --handler my-function.handler \ --role arn:aws:iam::111122223333:role/lambda-ex \ --snap-start ApplyOn=PublishedVersions ``` 1. Cree una versión con el comando [publish-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-version.html). ``` aws lambda publish-version \ --function-name my-function ``` 1. Confirme que SnapStart está activado para la versión de la función; para ello, ejecute el comando [get-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/get-function-configuration.html) y especifique el número de versión. El siguiente ejemplo especifica la versión 1. ``` aws lambda get-function-configuration \ --function-name my-function:1 ``` Si la respuesta muestra que [OptimizationStatus](https://docs.aws.amazon.com/lambda/latest/api/API_SnapStartResponse.html) es `On` y [Estado](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html#lambda-GetFunctionConfiguration-response-State) es `Active`, SnapStart se activa y hay una instantánea disponible para la versión de la función especificada. ``` "SnapStart": { "ApplyOn": "PublishedVersions", "OptimizationStatus": "On" }, "State": "Active", ``` 1. Para invocar la versión de la función, ejecute el comando [invoke](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/invoke.html) y especifique la versión. El siguiente ejemplo invoca la versión 1. ``` aws lambda invoke \ --cli-binary-format raw-in-base64-out \ --function-name my-function:1 \ --payload '{ "name": "Bob" }' \ response.json ``` La opción **cli-binary-format** es obligatoria si va a utilizar la versión 2 de la AWS CLI. Para que esta sea la configuración predeterminada, ejecute `aws configure set cli-binary-format raw-in-base64-out`. Para obtener más información, consulte [Opciones de la línea de comandos globales compatibles con AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) en la *Guía del usuario de la AWS Command Line Interface versión 2*. ## Activación de SnapStart (API) **Para activar SnapStart** 1. Realice una de las siguientes acciones: + Cree una nueva función con SnapStart activado mediante la acción de la API [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html) con el parámetro [SnapStart](https://docs.aws.amazon.com/lambda/latest/api/API_SnapStart.html). + Active SnapStart para una función existente mediante la acción [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html) con el parámetro [SnapStart](https://docs.aws.amazon.com/lambda/latest/api/API_SnapStart.html). 1. Publique una versión de la versión con la acción [publish-version](https://docs.aws.amazon.com/lambda/latest/api/API_PublishVersion.html). Lambda inicializa el código, crea una instantánea del entorno de ejecución inicializado y, a continuación, almacena la instantánea en caché para acceder a ella con baja latencia. 1. Confirme que SnapStart esté activado para la versión de la función mediante la acción [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html). Especifique un número de versión para confirmar que SnapStart está activado para esa versión. Si la respuesta muestra que [OptimizationStatus](https://docs.aws.amazon.com/lambda/latest/api/API_SnapStartResponse.html) es `On` y [Estado](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html#lambda-GetFunctionConfiguration-response-State) es `Active`, SnapStart se activa y hay una instantánea disponible para la versión de la función especificada. ``` "SnapStart": { "ApplyOn": "PublishedVersions", "OptimizationStatus": "On" }, "State": "Active", ``` 1. Invoque la versión de la función con la acción [Invoke](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html). ## Lambda SnapStart y estados de la función Se pueden producir los siguientes estados de función al utilizar SnapStart. **Pending (Pendiente)** Lambda está inicializando el código y tomando una instantánea del entorno de ejecución inicializado. Las invocaciones u otras acciones de API que actúen en la versión de la función producirán errores. **Activo** La creación de instantáneas está completa y puede invocar la función. Para usar SnapStart, debe invocar la versión de la función publicada, no la versión no publicada (\$1LATEST). **Inactivo ** El estado `Inactive` se puede producir cuando Lambda regenera periódicamente instantáneas de funciones para aplicar actualizaciones de software. En este caso, si la función no se inicializa, puede entrar en el estado `Inactive`. Para las funciones que utilizan un tiempo de ejecución de Java, Lambda elimina las instantáneas después de 14 días sin una invocación. Si invoca la versión de la función transcurridos 14 días, Lambda devuelve una respuesta `SnapStartNotReadyException` y comienza a inicializar una nueva instantánea. Espere hasta que la versión de la función alcance el estado `Active` y, a continuación, vuelva a invocarla. **Failed** Lambda encontró un error al ejecutar el código de inicialización o al crear la instantánea. ## Actualización de una instantánea Lambda crea una instantánea para cada versión de función publicada. Para actualizar una instantánea, publique una nueva versión de la función. ## Uso de SnapStart con AWS SDK Para realizar llamadas AWS SDK desde su función, Lambda genera un conjunto efímero de credenciales al asumir el rol de ejecución de la función. Estas credenciales están disponibles como variables de entorno durante la invocación de la función. No es necesario proporcionar las credenciales de SDK directamente en el código. De forma predeterminada, la cadena de proveedores de credenciales comprueba secuencialmente cada lugar en el que puede configurar las credenciales y elige el primero disponible, normalmente las variables de entorno (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, y `AWS_SESSION_TOKEN`). **nota** Cuando SnapStart se activa, el tiempo de ejecución de Lambda utiliza automáticamente las credenciales del contenedor (`AWS_CONTAINER_CREDENTIALS_FULL_URI` y `AWS_CONTAINER_AUTHORIZATION_TOKEN`) en lugar de las variables de entorno de la clave de acceso. Esto evita que las credenciales caduquen antes de que se restablezca la función. ## Uso de SnapStart con CloudFormation, AWS SAM y AWS CDK + **AWS CloudFormation:** declare la entidad [SnapStart](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-snapstart.html) en su plantilla. + **AWS Serverless Application Model (AWS SAM):** declare la propiedad [SnapStart](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-snapstart) en su plantilla. + **AWS Cloud Development Kit (AWS CDK):** utilice el tipo [SnapStartProperty](https://docs.aws.amazon.com/cdk/api/v2/java/software/amazon/awscdk/services/lambda/CfnFunction.SnapStartProperty.html). ## Eliminación de instantáneas Lambda elimina las instantáneas cuando sucede lo siguiente: + Elimina la función o la versión de la función. + **Solo tiempos de ejecución de Java**: no invoca la versión de la función durante 14 días. Tras 14 días sin una invocación, la versión de la función pasa al estado [Inactive](#snapstart-function-states) (Inactivo). Si invoca la versión de la función transcurridos 14 días, Lambda devuelve una respuesta `SnapStartNotReadyException` y comienza a inicializar una nueva instantánea. Espere hasta que la versión de la función alcance el estado [Active](#snapstart-function-states) (Activo) y, a continuación, vuelva a invocarla. Lambda elimina todos los recursos asociados a las instantáneas eliminadas de acuerdo con el Reglamento General de Protección de Datos (RGPD). # Control de la exclusividad con Lambda SnapStart Cuando las invocaciones escalar verticalmente en una función de SnapStart, Lambda utiliza una instantánea exclusiva inicializada para reanudar varios entornos de ejecución. Si el código de inicialización genera contenido único que se incluye en la instantánea, es posible que el contenido no lo sea cuando se reutilice en los entornos de ejecución. Para mantener la exclusividad al utilizar SnapStart, debe generar contenido único después de la inicialización. Esto incluye ID y secretos únicos y entropía que se utiliza para generar pseudoaleatoriedad. Sugerimos las siguientes prácticas recomendadas para ayudarlo a mantener la exclusividad en su código: Para las funciones de Java, Lambda también proporciona una [herramienta de escaneo de SnapStart](#snapstart-scanning) de código abierto para ayudar a comprobar si el código asume que es exclusivo. Si genera datos exclusivos durante la fase de inicialización, puede utilizar un [enlace de tiempo de ejecución](snapstart-runtime-hooks.md) para restaurar la exclusividad. Con los enlaces de tiempo de ejecución, puede ejecutar un código específico inmediatamente antes de que Lambda tome una instantánea o inmediatamente después de que Lambda reanude una función a partir de una instantánea. ## Evite guardar el estado que depende de la exclusividad durante la inicialización. Durante la [fase de inicialización](lambda-runtime-environment.md#runtimes-lifecycle-ib) de la función, evite almacenar en caché datos destinados a ser exclusivos, por ejemplo, generar un ID exclusivo para el registro o configurar valores de inicialización para funciones de asignación al azar. En su lugar, recomendamos que genere datos exclusivos o establezca valores de inicialización para funciones de asignación al azar dentro de su controlador de funciones, o que utilice un [enlace de tiempo de ejecución.](snapstart-runtime-hooks.md) En el ejemplo siguiente, se muestra cómo generar un UUID en el controlador de funciones. ------ #### [ Java ] **Example — Generar un ID exclusivo en el controlador de funciones** ``` import java.util.UUID; public class Handler implements RequestHandler { private static UUID uniqueSandboxId = null; @Override public String handleRequest(String event, Context context) { if (uniqueSandboxId == null) uniqueSandboxId = UUID.randomUUID(); System.out.println("Unique Sandbox Id: " + uniqueSandboxId); return "Hello, World!"; } } ``` ------ #### [ Python ] **Example — Generar un ID exclusivo en el controlador de funciones** ``` import json import random import time unique_number = None def lambda_handler(event, context): seed = int(time.time() * 1000) random.seed(seed) global unique_number if not unique_number: unique_number = random.randint(1, 10000) print("Unique number: ", unique_number) return "Hello, World!" ``` ------ #### [ .NET ] **Example — Generar un ID exclusivo en el controlador de funciones** ``` namespace Example; public class SnapstartExample { private Guid _myExecutionEnvironmentGuid; public SnapstartExample() { // This GUID is set for non-restore use cases, such as testing or if SnapStart is turned off _myExecutionEnvironmentGuid = new Guid(); // Register the method which will run after each restore. You may need to update Amazon.Lambda.Core to see this Amazon.Lambda.Core.SnapshotRestore.RegisterAfterRestore(MyAfterRestore); } private ValueTask MyAfterRestore() { // After restoring this snapshot to a new execution environment, update the GUID _myExecutionEnvironmentGuid = new Guid(); return ValueTask.CompletedTask; } public string Handler() { return $"Hello World! My Execution Environment GUID is {_myExecutionEnvironmentGuid}"; } } ``` ------ ## Utilice generadores de números pseudoaleatorios criptográficamente seguros (CSPRNG) Si su aplicación depende de la aleatoriedad, le recomendamos que utilice generadores de números pseudoaleatorios criptográficamente seguros. Además de OpenSSL 1.0.2, los tiempos de ejecución administrados por Lambda también incluyen los siguientes CSPRNG integrados: + **Java:** `java.security.SecureRandom` + **Python:** `random.SystemRandom` + **.NET:** `System.Security.Cryptography.RandomNumberGenerator` Software que siempre obtiene números aleatorios de `/dev/random` o `/dev/urandom` también mantiene la aleatoriedad con SnapStart. Las bibliotecas de criptografía de AWS mantienen automáticamente la aleatoriedad con SnapStart a partir de las versiones mínimas especificadas en la siguiente tabla. Si utiliza estas bibliotecas con las funciones de Lambda, asegúrese de usar las siguientes versiones mínimas o posteriores: **** | Library | Versión mínima compatible (x86) | Versión mínima compatible (ARM) | | --- | --- | --- | | AWS libcrypto (AWS-LC) | 1.16.0 | 1.30.0 | | AWS libcrypto FIPS | 2.0.13 | 2.0.13 | Si empaqueta las bibliotecas criptográficas anteriores con sus funciones de Lambda como dependencias transitivas a través de las siguientes bibliotecas, asegúrese de utilizar las siguientes versiones mínimas o posteriores: **** | Library | Versión mínima compatible (x86) | Versión mínima compatible (ARM) | | --- | --- | --- | | AWS SDK for Java 2.x | 2.23.20 | 2.26.12 | | AWS Common Runtime for Java | 0.29.8 | 0.29.25 | | Amazon Corretto Crypto Provider | 2.4.1 | 2.4.1 | | Amazon Corretto Crypto Provider, FIPS | 2.4.1 | 2.4.1 | En los siguientes ejemplos, se demuestra cómo utilizar los CSPRNG para garantizar secuencias numéricas exclusivas incluso cuando la función se restaura a partir de una instantánea. ------ #### [ Java ] **Example — java.security.Secure Random** ``` import java.security.SecureRandom; public class Handler implements RequestHandler { private static SecureRandom rng = new SecureRandom(); @Override public String handleRequest(String event, Context context) { for (int i = 0; i < 10; i++) { System.out.println(rng.next()); } return "Hello, World!"; } } ``` ------ #### [ Python ] **Example – random.SystemRandom** ``` import json import random secure_rng = random.SystemRandom() def lambda_handler(event, context): random_numbers = [secure_rng.random() for _ in range(10)] for number in random_numbers: print(number) return "Hello, World!" ``` ------ #### [ .NET ] **Example – RandomNumberGenerator** ``` using Amazon.Lambda.Core; using System.Security.Cryptography; [assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))] namespace DotnetSecureRandom; public class Function { public string FunctionHandler() { using (RandomNumberGenerator rng = RandomNumberGenerator.Create()) { byte[] randomUnsignedInteger32Bytes = new byte[4]; for (int i = 0; i < 10; i++) { rng.GetBytes(randomUnsignedInteger32Bytes); int randomInt32 = BitConverter.ToInt32(randomUnsignedInteger32Bytes, 0); Console.WriteLine("{0:G}", randomInt32); } } return "Hello World!"; } } ``` ------ ## Herramienta de escaneo de SnapStart (solo Java) Lambda proporciona una herramienta de escaneo para Java que lo ayuda a verificar el código que asume exclusividad. La herramienta de escaneo SnapStart es un complemento de [SpotBugs](https://spotbugs.github.io/) de código abierto que ejecuta un análisis estático en función de un conjunto de reglas. La herramienta de escaneo ayuda a identificar posibles implementaciones de código que podrían romper las suposiciones con respecto a la exclusividad. Para obtener instrucciones de instalación y una lista de las comprobaciones que realiza la herramienta de escaneo, consulte el repositorio [aws-lambda-snapstart-java-rules](https://github.com/aws/aws-lambda-snapstart-java-rules) en GitHub. Para obtener más información sobre cómo gestionar la exclusividad con SnapStart, consulte [Inicio más rápido con AWS Lambda SnapStart](https://aws.amazon.com/blogs/compute/starting-up-faster-with-aws-lambda-snapstart/) en el blog de computación de AWS. # 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 }; } } ``` # Monitoreo para Lambda SnapStart Puede monitorear las funciones de Lambda SnapStart con Amazon CloudWatch, AWS X-Ray y la [Acceso a datos de telemetría en tiempo real para extensiones mediante la API de telemetría](telemetry-api.md). **nota** Las [variables de entorno](configuration-envvars.md#configuration-envvars-runtime) `AWS_LAMBDA_LOG_GROUP_NAME` y `AWS_LAMBDA_LOG_STREAM_NAME` no están disponibles en las funciones de Lambda SnapStart. ## Comprenda el comportamiento de registro y facturación con SnapStart Hay algunas diferencias con el formato de [flujo de registro de CloudWatch](monitoring-cloudwatchlogs.md) para las funciones de SnapStart: + **Registros de inicialización**: cuando se crea un nuevo entorno de ejecución, el `REPORT` no incluye el campo `Init Duration`. Esto se debe a que Lambda inicializa las funciones de SnapStart cuando se crea una versión, en lugar de durante la invocación de la función. Para las funciones de SnapStart, el campo `Init Duration` está en el registro `INIT_REPORT`. Este registro muestra los detalles de [Fase "init"](lambda-runtime-environment.md#runtimes-lifecycle-ib), lo que incluye la duración de cualquier [enlace de tiempo de ejecución](snapstart-runtime-hooks.md) de `beforeCheckpoint`. + **Registros de invocación**: cuando se crea un nuevo entorno de ejecución, el `REPORT` incluye los campos `Restore Duration` y `Billed Restore Duration`: + `Restore Duration`: el tiempo que tarda Lambda en restaurar una instantánea, cargar el tiempo de ejecución y ejecutar cualquier [enlace de tiempo de ejecución](snapstart-runtime-hooks.md) posterior a la restauración. El proceso de restauración de instantáneas puede incluir el tiempo dedicado a actividades fuera de la micro VM. Este tiempo se informa en `Restore Duration`. + `Billed Restore Duration`: el tiempo que tarda Lambda en cargar el tiempo de ejecución y ejecutar cualquier [enlace de tiempo de ejecución](snapstart-runtime-hooks.md) posterior a la restauración. **nota** Como ocurre con todas las funciones de Lambda, los cargos por duración se aplican al código que se ejecuta en el controlador de funciones. Para las funciones de SnapStart, también se aplican cargos por duración al código de inicialización declarado fuera del controlador, al tiempo que tarda en cargarse el entorno de ejecución y a cualquier código que se ejecute en un [enlace del tiempo de ejecución](snapstart-runtime-hooks.md). La duración del arranque en frío es la suma de `Restore Duration` \$1 `Duration`. El siguiente ejemplo es una consulta de Lambda Insights que devuelve los percentiles de latencia de las funciones de SnapStart. Para obtener más información sobre las consultas de Lambda Insights, consulte [Ejemplo de flujo de trabajo mediante consultas para solucionar problemas de una función](monitoring-insights.md#monitoring-insights-queries). ``` filter @type = "REPORT" | parse @log /\d+:\/aws\/lambda\/(?.*)/ | parse @message /Restore Duration: (?.*?) ms/ | stats count(*) as invocations, pct(@duration+coalesce(@initDuration,0)+coalesce(restoreDuration,0), 50) as p50, pct(@duration+coalesce(@initDuration,0)+coalesce(restoreDuration,0), 90) as p90, pct(@duration+coalesce(@initDuration,0)+coalesce(restoreDuration,0), 99) as p99, pct(@duration+coalesce(@initDuration,0)+coalesce(restoreDuration,0), 99.9) as p99.9 group by function, (ispresent(@initDuration) or ispresent(restoreDuration)) as coldstart | sort by coldstart desc ``` ## Seguimiento activo de X-Ray para SnapStart Puede usar [X-Ray](services-xray.md) para rastrear las solicitudes a las funciones de Lambda SnapStart. Hay algunas diferencias con los subsegmentos de X-Ray de las funciones SnapStart: + No hay ningún subsegmento de `Initialization` para las funciones SnapStart. + El subsegmento `Restore` muestra el tiempo que tarda Lambda en restaurar una instantánea, cargar el tiempo de ejecución y ejecutar cualquier [enlace de tiempo de ejecución](snapstart-runtime-hooks.md) posterior a la restauración. El proceso de restauración de instantáneas puede incluir el tiempo dedicado a actividades fuera de la micro VM. Esta vez se informa en el subsegmento `Restore`. No se le cobrará por el tiempo que pase fuera de la micro VM para restaurar una instantánea. ## Eventos de la API de telemetría para SnapStart Lambda envía los siguientes eventos de SnapStart a [API de telemetría](telemetry-api.md): + [`platform.restoreStart`](telemetry-schema-reference.md#platform-restoreStart): muestra la hora en que comenzó la [fase `Restore`](lambda-runtime-environment.md#runtimes-lifecycle-restore). + [`platform.restoreRuntimeDone`](telemetry-schema-reference.md#platform-restoreRuntimeDone): muestra si la fase `Restore` se ha realizado correctamente. Lambda envía este mensaje cuando el tiempo de ejecución envía una solicitud de API `restore/next` de tiempo de ejecución. Hay tres estados posibles: éxito, error y tiempo de espera agotado. + [`platform.restoreReport`](telemetry-schema-reference.md#platform-restoreReport): muestra cuánto duró la fase `Restore` y cuántos milisegundos se le facturaron durante esta fase. ## Métricas de URL de función y Amazon API Gateway Si crea una API web [con API Gateway](services-apigateway.md), puede utilizar la métrica de [IntegrationLatency](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-metrics-and-dimensions.html) para medir la latencia completa (el tiempo transcurrido entre el momento en que API Gateway transmite una solicitud al backend y el momento en que recibe una respuesta del backend). Si utiliza la [URL de función de Lambda](urls-configuration.md), puede utilizar la métrica [URLRequestLatency](urls-monitoring.md) para medir la latencia completa (el tiempo transcurrido entre el momento en que la URL de función recibe una solicitud y el momento en que la URL de función devuelve una respuesta). # Modelo de seguridad para Lambda SnapStart Lambda SnapStart admite el cifrado en reposo. Lambda cifra las instantáneas con una AWS KMS key. De forma predeterminada, Lambda utiliza una Clave administrada de AWS. Si este comportamiento predeterminado se ajusta a su flujo de trabajo, no tiene que configurar nada más. De lo contrario, puede utilizar la opción `--kms-key-arn` del comando [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) o [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) para proporcionar una clave AWS KMS gestionada por el cliente. Puede hacerlo para controlar la rotación de la clave de KMS o para cumplir con los requisitos de su organización para administrar claves de KMS. Las claves administradas por el cliente ocasionan cargos de AWS KMS estándar. Para más información, consulte [Precios de AWS Key Management Service](https://aws.amazon.com/kms/pricing/). Al eliminar una función o versión de la función de SnapStart, fallan todas las solicitudes de `Invoke` a esa función o versión de la función. Lambda elimina todos los recursos asociados a las instantáneas eliminadas de acuerdo con el Reglamento General de Protección de Datos (RGPD). # Maximice el rendimiento de Lambda SnapStart **Topics** + [ ## Ajuste del rendimiento ](#snapstart-tuning) + [ ## Prácticas recomendadas para redes ](#snapstart-networking) ## Ajuste del rendimiento Para maximizar los beneficios de SnapStart, tenga en cuenta las siguientes recomendaciones de optimización de código para su tiempo de ejecución. **nota** SnapStart funciona mejor cuando se usa con invocaciones de funciones a escala. Es posible que las funciones que se invocan con poca frecuencia no experimenten las mismas mejoras de rendimiento. ### Java Para maximizar las ventajas de SnapStart, recomendamos que precargue las dependencias e inicialice los recursos que contribuyen a la latencia de inicio en el código de inicialización en lugar de hacerlo en el controlador de funciones. Esto elimina de la ruta de invocación la latencia asociada a la carga pesada de clases, lo que optimiza el rendimiento de inicio con SnapStart. Si no puede precargar las dependencias o recursos durante la inicialización, recomendamos que las precargue con invocaciones ficticias. Para ello, actualice el código del controlador de funciones, como se muestra en el siguiente ejemplo de la [función tienda de mascotas](https://github.com/awslabs/aws-serverless-java-container/tree/main/samples/spring/pet-store) del repositorio de Labs GitHub de AWS. ``` private static SpringLambdaContainerHandler handler; static { try { handler = SpringLambdaContainerHandler.getAwsProxyHandler(PetStoreSpringAppConfig.class); // Use the onStartup method of the handler to register the custom filter handler.onStartup(servletContext -> { FilterRegistration.Dynamic registration = servletContext.addFilter("CognitoIdentityFilter", CognitoIdentityFilter.class); registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, "/*"); }); // Send a fake Amazon API Gateway request to the handler to load classes ahead of time ApiGatewayRequestIdentity identity = new ApiGatewayRequestIdentity(); identity.setApiKey("foo"); identity.setAccountId("foo"); identity.setAccessKey("foo"); AwsProxyRequestContext reqCtx = new AwsProxyRequestContext(); reqCtx.setPath("/pets"); reqCtx.setStage("default"); reqCtx.setAuthorizer(null); reqCtx.setIdentity(identity); AwsProxyRequest req = new AwsProxyRequest(); req.setHttpMethod("GET"); req.setPath("/pets"); req.setBody(""); req.setRequestContext(reqCtx); Context ctx = new TestContext(); handler.proxy(req, ctx); } catch (ContainerInitializationException e) { // if we fail here. We re-throw the exception to force another cold start e.printStackTrace(); throw new RuntimeException("Could not initialize Spring framework", e); } } ``` ### Python Para maximizar los beneficios de SnapStart, concéntrese en la organización eficiente del código y la administración de recursos dentro de sus funciones de Python. Como pauta general, realice tareas computacionales excesivas durante la [fase de inicialización](lambda-runtime-environment.md#runtimes-lifecycle-ib). Este enfoque elimina las operaciones que consumen mucho tiempo de la ruta de invocación, lo que mejora el rendimiento general de la función. Recomendamos que siga las siguientes prácticas recomendadas para implementar esta estrategia de manera efectiva: + Importe dependencias fuera del controlador de funciones. + Cree instancias `boto3` fuera del controlador. + Inicialice las configuraciones o los recursos estáticos antes de invocar el controlador. + Considere la posibilidad de utilizar un [enlace de tiempo de ejecución](snapstart-runtime-hooks-python.md) previo a la instantánea para tareas que consuman muchos recursos, como descargar archivos externos, precargar marcos como Django o cargar modelos de machine learning. **Example Optimización de la función de Python para SnapStart** ``` # Import all dependencies outside of Lambda handler from snapshot_restore_py import register_before_snapshot import boto3 import pandas import pydantic # Create S3 and SSM clients outside of Lambda handler s3_client = boto3.client("s3") # Register the function to be called before snapshot @register_before_snapshot def download_llm_models(): # Download an object from S3 and save to tmp # This files will persist in this snapshot with open('/tmp/FILE_NAME', 'wb') as f: s3_client.download_fileobj('amzn-s3-demo-bucket', 'OBJECT_NAME', f) ... def lambda_handler(event, context): ... ``` ### .NET Para reducir el tiempo de carga del ensamblaje y la compilación justo a tiempo (JIT), considere invocar el controlador de funciones desde un [enlace de tiempo de ejecución](snapstart-runtime-hooks-dotnet.md) `RegisterBeforeCheckpoint`. Debido al funcionamiento de la compilación por niveles de .NET, obtendrá resultados óptimos si invoca el controlador varias veces, como se muestra en el siguiente ejemplo. **importante** Asegúrese de que la invocación de una función ficticia no produzca efectos secundarios no deseados, como el inicio de transacciones comerciales. **Example** ``` public class Function { public Function() { Amazon.Lambda.Core.SnapshotRestore.RegisterBeforeSnapshot(FunctionWarmup); } // Warmup method that calls the function handler before snapshot to warm up the .NET code and runtime. // This speeds up future cold starts after restoring from a snapshot. private async ValueTask FunctionWarmup() { var request = new APIGatewayProxyRequest { Path = "/heathcheck", HttpMethod = "GET" }; for (var i = 0; i < 10; i++) { await FunctionHandler(request, null); } } public async Task FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context) { // // Process HTTP request // var response = new APIGatewayProxyResponse { StatusCode = 200 }; return await Task.FromResult(response); } } ``` ## Prácticas recomendadas para redes El estado de las conexiones que establece la función durante la fase de inicialización no está garantizado cuando Lambda vuelve a activar la función a partir de una instantánea. En la mayoría de los casos, las conexiones de red que establece un SDK de AWS se reanudan automáticamente. Recomendamos que siga las siguientes prácticas recomendadas para otras conexiones. **Restablezca las conexiones de red.** Restablezca siempre las conexiones de red cuando la función se reanude a partir de una instantánea. Se recomienda restablecer las conexiones de red en el controlador de funciones. Como alternativa, puede utilizar un [enlace de tiempo de ejecución](snapstart-runtime-hooks.md) después de restaurar. **No utilice el nombre de host como identificador único del entorno de ejecución.** Se recomienda no utilizar un `hostname` para identificar el entorno de ejecución como un nodo o contenedor único en las aplicaciones. Con SnapStart, se utiliza una única instantánea como estado inicial para varios entornos de ejecución. Todos los entornos de ejecución devuelven el mismo valor `hostname` para `InetAddress.getLocalHost()` (Java), `socket.gethostname()` (Python) y `Dns.GetHostName()` (.NET). Para las aplicaciones que requieren una identidad de entorno de ejecución o un valor de `hostname` único, se recomienda generar un ID único en el controlador de funciones. O bien, utilice un [enlace de tiempo de ejecución](snapstart-runtime-hooks.md) después de restaurar para generar un ID único y, a continuación, utilice el ID único como identificador del entorno de ejecución. **Evite vincular conexiones a puertos de origen fijos.** Se recomienda evitar vincular las conexiones de red a puertos de origen fijos. Las conexiones se restablecen cuando se reanuda una función a partir de una instantánea y las conexiones de red que están enlazadas a un puerto de origen fijo pueden fallar. **Evite utilizar la caché de DNS de Java.** Las funciones de Lambda ya almacenan en caché las respuestas de DNS. Si utiliza otra caché de DNS con SnapStart, es posible que se agoten los tiempos de espera de conexión cuando la función se reanude a partir de una instantánea. La clase `java.util.logging.Logger` puede habilitar indirectamente la caché de DNS de la JVM. Para anular la configuración predeterminada, defina [networkaddress.cache.ttl](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/net/InetAddress.html#inetaddress-caching-heading) en 0 antes de inicializar `logger`. Ejemplo: ``` public class MyHandler { // first set TTL property static{ java.security.Security.setProperty("networkaddress.cache.ttl" , "0"); } // then instantiate logger var logger = org.apache.logging.log4j.LogManager.getLogger(MyHandler.class); } ``` Para evitar errores `UnknownHostException` en el tiempo de ejecución de Java 11, se recomienda establecer el valor `networkaddress.cache.negative.ttl` en 0. En Java 17 y tiempos de ejecución posteriores, este paso no es necesario. Puede establecer esta propiedad para una función de Lambda con la variable de entorno `AWS_LAMBDA_JAVA_NETWORKADDRESS_CACHE_NEGATIVE_TTL=0`. Al deshabilitar la caché de DNS de la JVM, no se deshabilita la caché de DNS administrada de Lambda. # Solución de problemas de errores de SnapStart para funciones de Lambda En esta página se abordan los problemas comunes que se producen al usar SnapStart de Lambda, incluidos los errores de creación de instantáneas, los errores de tiempo de espera y los errores de servicio interno. ## SnapStartNotReadyException **Error:** se produjo un error (SnapStartNotReadyException) al llamar a la operación Invoke20150331: Lambda está inicializando la función. Estará lista para invocarse una vez que el estado de la función pase a estar ACTIVO. ### Causas habituales Este error se produce al intentar invocar una versión de función que se encuentra en el [estado](snapstart-activate.md#snapstart-function-states) `Inactive`. La versión de la función pasa a un estado `Inactive` cuando no se ha invocado durante 14 días o cuando Lambda recicla periódicamente el entorno de ejecución. ### Resolución Espere hasta que la versión de la función alcance el estado `Active` y, a continuación, vuelva a invocarla. ## SnapStartTimeoutException **Problema:** recibe una excepción `SnapStartTimeoutException` cuando intenta invocar una versión de la función SnapStart. ### Causa habitual Durante la fase de [Restauración](lambda-runtime-environment.md#runtimes-lifecycle-restore), Lambda restaura el tiempo de ejecución de Java y ejecuta todos los [enlaces en tiempo de ejecución](snapstart-runtime-hooks.md) posteriores a la restauración. Si un enlace de tiempo de ejecución posterior a la restauración se ejecuta durante más de 10 segundos, la fase `Restore` expira y se obtiene un error cuando se intenta invocar la función. Los problemas con la conexión de red y las credenciales también pueden provocar tiempos de espera de la fase `Restore`. ### Resolución Compruebe los registros de CloudWatch de la función para ver si hay errores de tiempo de espera que se hayan producido durante la fase [Restore](lambda-runtime-environment.md#runtimes-lifecycle-restore). Asegúrese de que todos los enlaces posteriores a la restauración se completen en menos de 10 segundos. **Example Registro de CloudWatch** ``` { "cause": "Lambda couldn't restore the snapshot within the timeout limit. (Service: Lambda, Status Code: 408, Request ID: 11a222c3-410f-427c-ab22-931d6bcbf4f2)", "error": "Lambda.SnapStartTimeoutException"} ``` ## Error de servicio interno 500 **Error:** Lambda no ha podido crear una nueva instantánea porque ha alcanzado el límite de creación simultánea de instantáneas. ### Causa habitual Un error 500 es un error interno del propio servicio de Lambda y no un problema con la función o el código. Estos errores suelen ser intermitentes. ### Resolución Intente volver a publicar la versión de la función. ## 401 sin autorización **Error:** el token de sesión o la clave de cabecera son incorrectos ### Causa habitual Este error se produce al utilizar el [Almacén de parámetros de AWS Systems Manager y la extensión AWS Secrets Manager](with-secrets-manager.md) con SnapStart de Lambda. ### Resolución El Almacén de parámetros de AWS Systems Manager y la extensión AWS Secrets Manager no son compatibles con SnapStart. La extensión genera credenciales para comunicarse con AWS Secrets Manager durante la inicialización de la función, lo que provoca errores en las credenciales caducadas cuando se utiliza con SnapStart. ## UnknownHostException (Java) **Error:** no se puede ejecutar la solicitud HTTP: el certificado `abc.us-east-1.amazonaws.com` no coincide con ninguno de los nombres alternativos del asunto. ### Causa habitual Las funciones de Lambda ya almacenan en caché las respuestas de DNS. Si utiliza otra caché de DNS con SnapStart, es posible que se agoten los tiempos de espera de conexión cuando la función se reanude a partir de una instantánea. ### Resolución Para evitar errores `UnknownHostException` en el tiempo de ejecución de Java 11, se recomienda establecer el valor `networkaddress.cache.negative.ttl` en 0. En Java 17 y tiempos de ejecución posteriores, este paso no es necesario. Puede establecer esta propiedad para una función de Lambda con la variable de entorno `AWS_LAMBDA_JAVA_NETWORKADDRESS_CACHE_NEGATIVE_TTL=0`. ## Fallos en la creación de la instantánea **Error:** AWS Lambda no pudo invocar la función SnapStart. Si el error persiste, compruebe los registros de CloudWatch de su función para comprobar si hay errores de inicialización. ### Resolución Revise los registros de Amazon CloudWatch de su función para ver los tiempos de espera de los [enlaces de tiempo de ejecución](snapstart-runtime-hooks.md) anteriores a la comprobación. También puede intentar publicar una nueva versión de la función, lo que a veces puede resolver el problema. ## Latencia de creación de instantáneas **Problema:** al publicar una nueva versión de una función, la función permanece en el [estado](snapstart-activate.md#snapstart-function-states) `Pending` durante mucho tiempo. ### Causa habitual 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. Si la función está [adjunta a una VPC](configuration-vpc.md#configuration-vpc-attaching), es posible que Lambda también necesite crear interfaces de red antes de que la función pase a un estado `Active`. Si intenta invocar la versión de la función mientras la función está en estado `Pending`, es posible que obtenga un error 409 `ResourceConflictException`. Si la función se invoca mediante un punto de conexión de Amazon API Gateway, es posible que aparezca un error 500 en API Gateway. ### Resolución Espere al menos 15 minutos a que se inicialice la versión de la función antes de invocarla.