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.
En esta página se describe cómo se trabaja con los controladores de funciones de Lambda en C# para usar el tiempo de ejecución administrado de. NET, incluidas las opciones para la configuración del proyecto, las convenciones de nomenclatura y las prácticas recomendadas. En esta página también se incluye el ejemplo de una función de Lambda de C# que recibe información sobre un pedido, genera un recibo en un archivo de texto y coloca este archivo en un bucket de Amazon Simple Storage Service (S3). Para obtener información sobre cómo implementar la función después de escribirla, consulte Crear e implementar funciones de Lambda C# con archivos de archivo .zip o Implementar funciones de Lambda .NET con imágenes de contenedor.
Temas
Configuración del proyecto del controlador de C#
Cuando se trabaja con funciones de Lambda en C#, el proceso implica escribir el código y, posteriormente, implementarlo en Lambda. Existen dos modelos de ejecución diferentes para ejecutar funciones de Lambda en .NET: el enfoque de biblioteca de clases y el enfoque de conjuntos ejecutables.
En el enfoque de biblioteca de clases, se empaqueta el código de función como un conjunto de .NET (.dll) y se implementa en Lambda con el tiempo de ejecución administrado de .NET (dotnet8). Para el nombre del controlador, Lambda espera una cadena en el formato AssemblyName::Namespace.Classname::Methodname. Durante la fase de inicialización de la función, se inicializa la clase de la función y se ejecuta cualquier código del constructor.
En el enfoque de conjuntos ejecutables, se usa la característica de instrucciones de nivel superiordotnet8). Para el nombre del controlador, debe proporcionar a Lambda el nombre del conjunto ejecutable que se va a ejecutar.
En el ejemplo principal de esta página se ilustra el enfoque de biblioteca de clases. Puede inicializar su proyecto de Lambda en C# de varias formas, pero la forma más sencilla es usar la CLI de .NET con la CLI de Amazon.Lambda.Tools. Configure la CLI de Amazon.Lambda.Tools siguiendo los pasos que se indican en Configuración del entorno de desarrollo de .NET. A continuación, inicialice el proyecto con el siguiente comando:
dotnet new lambda.EmptyFunction --name ExampleCSEste comando genera la siguiente estructura de archivos:
/project-root └ src └ ExampleCS └ Function.cs (contains main handler) └ Readme.md └ aws-lambda-tools-defaults.json └ ExampleCS.csproj └ test └ ExampleCS.Tests └ FunctionTest.cs (contains main handler) └ ExampleCS.Tests.csproj
En esta estructura de archivos, la lógica del controlador principal de la función reside en el archivo Function.cs.
Ejemplo de código de una función de Lambda en C#
El siguiente ejemplo de código de función de Lambda en C# recibe información sobre un pedido, genera un recibo en un archivo de texto y coloca este archivo en un bucket de Amazon S3.
ejemplo Función de Lambda Function.cs
using System;
using System.Text;
using System.Threading.Tasks;
using Amazon.Lambda.Core;
using Amazon.S3;
using Amazon.S3.Model;
// Assembly attribute to enable Lambda function logging
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace ExampleLambda;
public class Order
{
public string OrderId { get; set; } = string.Empty;
public double Amount { get; set; }
public string Item { get; set; } = string.Empty;
}
public class OrderHandler
{
private static readonly AmazonS3Client s3Client = new();
public async Task<string> HandleRequest(Order order, ILambdaContext context)
{
try
{
string? bucketName = Environment.GetEnvironmentVariable("RECEIPT_BUCKET");
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new ArgumentException("RECEIPT_BUCKET environment variable is not set");
}
string receiptContent = $"OrderID: {order.OrderId}\nAmount: ${order.Amount:F2}\nItem: {order.Item}";
string key = $"receipts/{order.OrderId}.txt";
await UploadReceiptToS3(bucketName, key, receiptContent);
context.Logger.LogInformation($"Successfully processed order {order.OrderId} and stored receipt in S3 bucket {bucketName}");
return "Success";
}
catch (Exception ex)
{
context.Logger.LogError($"Failed to process order: {ex.Message}");
throw;
}
}
private async Task UploadReceiptToS3(string bucketName, string key, string receiptContent)
{
try
{
var putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = receiptContent,
ContentType = "text/plain"
};
await s3Client.PutObjectAsync(putRequest);
}
catch (AmazonS3Exception ex)
{
throw new Exception($"Failed to upload receipt to S3: {ex.Message}", ex);
}
}
}Este archivo Function.cs contiene las siguientes secciones de código:
-
Instrucciones de
using: úselas para importar las clases de C# que requiere la función de Lambda. -
[assembly: LambdaSerializer(...)]:LambdaSerializeres un atributo de conjunto que indica a Lambda que convierta automáticamente las cargas útiles de eventos JSON en objetos de C# antes de pasarlos a su función. -
namespace ExampleLambda: esto define el espacio de nombres. En C#, el nombre del espacio de nombres no tiene que coincidir con el nombre del archivo. -
public class Order {...}: esto define la forma del evento de entrada esperado. -
public class OrderHandler {...}: esto define su clase de C#. Dentro de ella, definirá el método de controlador principal y cualquier otro método auxiliar. -
private static readonly AmazonS3Client s3Client = new();: esto inicializa un cliente de Amazon S3 con la cadena de proveedores de credenciales predeterminada, fuera del método del controlador principal. Esto hace que Lambda ejecute este código durante la fase de inicialización. -
public async ... HandleRequest (Order order, ILambdaContext context): este es el método del controlador principal, que contiene la lógica principal de la aplicación. -
private async Task UploadReceiptToS3(...) {}: este es un método auxiliar al que hace referencia el método del controlador principalhandleRequest.
Dado que esta función requiere un cliente del SDK de Amazon S3, debe agregarlo a las dependencias del proyecto. Para hacerlo, navegue a src/ExampleCS y ejecute el siguiente comando:
dotnet add package AWSSDK.S3De forma predeterminada, el archivo aws-lambda-tools-defaults.json generado no contiene información de profile ni region para su función. Además, actualice la cadena function-handler al valor correcto (ExampleCS::ExampleLambda.OrderHandler::HandleRequest). Puede llevar a cabo esta actualización manualmente y agregar los metadatos necesarios para usar un perfil de credenciales y una región específicos para su función. Por ejemplo, el archivo aws-lambda-tools-defaults.json debe ser similar al siguiente ejemplo:
{
"Information": [
"This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.",
"To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.",
"dotnet lambda help",
"All the command line options for the Lambda command can be specified in this file."
],
"profile": "default",
"region": "us-east-1",
"configuration": "Release",
"function-architecture": "x86_64",
"function-runtime": "dotnet8",
"function-memory-size": 512,
"function-timeout": 30,
"function-handler": "ExampleCS::ExampleLambda.OrderHandler::HandleRequest"
}Para que esta función se ejecute correctamente, su rol de ejecución debe permitir la acción s3:PutObject. Si usa el comando dotnet lambda deploy-function (es decir, dotnet lambda deploy-function ExampleCS), la política AWSLambdaExecute en las peticiones de la CLI contiene los permisos necesarios para que pueda invocar esta función correctamente.
Además, asegúrese de que
Finalmente, asegúrese de definir la variable de entorno RECEIPT_BUCKET. Tras una invocación correcta, el bucket de Amazon S3 debe contener un archivo de recibo.
Controladores de bibliotecas de clases
En el ejemplo de código principal de esta página se ilustra un controlador de biblioteca de clases. Los controladores de biblioteca de clases tienen la siguiente estructura:
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace NAMESPACE;
...
public class CLASSNAME {
public async Task<string> METHODNAME (...) {
...
}
}Al crear una función de Lambda, debe proporcionar a Lambda información sobre el controlador de la función en forma de cadena en el campo Handler. Esto le indica a Lambda qué método del código debe ejecutar cuando se invoque la función. En C#, para los controladores de biblioteca de clases, el formato de la cadena del controlador es ASSEMBLY::TYPE::METHOD, donde:
-
ASSEMBLYes el nombre del archivo de conjunto de .NET para la aplicación. Si usa la CLI deAmazon.Lambda.Toolspara compilar la aplicación y no establece el nombre del conjunto con la propiedadAssemblyNamedel archivo.csproj, entoncesASSEMBLYserá simplemente el nombre del archivo.csproj. -
TYPEes el nombre completo del tipo de controlador, que esNAMESPACE.CLASSNAME. -
METHODes el nombre del método de controlador principal en el código, que esMETHODNAME.
En el ejemplo de código que se muestra en esta página, si se nombra el conjunto como ExampleCS, entonces la cadena del controlador sería ExampleCS::ExampleLambda.OrderHandler::HandleRequest.
Controladores de conjuntos ejecutables
También puede definir las funciones de Lambda en C# como un conjunto ejecutable. Los controladores de conjuntos ejecutables usan la característica de instrucciones de nivel superior de C#, en la que el compilador genera el método Main() y coloca el código de la función en él. Cuando se utilizan ensamblados ejecutables, se debe iniciar el tiempo de ejecución de Lambda. Para ello, se usa el método LambdaBootstrapBuilder.Create en el código. Las entradas de este método son la función de controlador principal y el serializador de Lambda que se usará. A continuación se muestra un ejemplo de un controlador de conjunto ejecutable en C#:
namespace GetProductHandler;
IDatabaseRepository repo = new DatabaseRepository();
await LambdaBootstrapBuilder.Create<APIGatewayProxyRequest>(Handler, new DefaultLambdaJsonSerializer())
.Build()
.RunAsync();
async Task<APIGatewayProxyResponse> Handler(APIGatewayProxyRequest apigProxyEvent, ILambdaContext context)
{
var id = apigProxyEvent.PathParameters["id"];
var databaseRecord = await this.repo.GetById(id);
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK,
Body = JsonSerializer.Serialize(databaseRecord)
};
};En el campo Handler de controladores de conjuntos ejecutables, la cadena de controlador que le dice a Lambda cómo ejecutar el código es el nombre del conjunto. En este ejemplo, es GetProductHandler.
Firmas de controlador válidas para funciones de C#
En C#, las firmas de controlador de Lambda válidas aceptan entre 0 y 2 argumentos. Por lo general, la firma de su controlador tiene dos argumentos, como se muestra en el ejemplo principal:
public async Task<string> HandleRequest(Order order, ILambdaContext context)Al proporcionar dos argumentos, el primero debe ser la entrada del evento y el segundo debe ser el objeto de contexto de Lambda. Ambos argumentos son opcionales. Por ejemplo, las siguientes firmas de controlador de Lambda también son válidas en C#:
-
public async Task<string> HandleRequest() -
public async Task<string> HandleRequest(Order order) -
public async Task<string> HandleRequest(ILambdaContext context)
Además de la sintaxis básica de la firma del controlador, existen algunas restricciones adicionales:
-
No puede usar la palabra clave
unsafeen la firma del controlador. Sin embargo, puede usar el contextounsafedentro del método del controlador y sus dependencias. Para obtener más información, consulte unsafe (Referencia de C#)en el sitio web de documentación de Microsoft. -
El controlador no puede usar la palabra clave
paramsni usarArgIteratorcomo parámetro de entrada o retorno. Estas palabras clave admiten un número variable de parámetros. El número máximo de argumentos que el controlador puede aceptar es dos. -
El controlador no puede ser un método genérico. En otras palabras, no puede usar parámetros de tipo genérico como
<T>. -
Lambda no admite controladores asíncronos con
async voiden la firma.
Convenciones de nomenclatura de controladores
Los controladores de Lambda en C# no tienen restricciones de nomenclatura estrictas. Sin embargo, debe asegurarse de proporcionar la cadena de controlador correcta a Lambda al implementar la función. La cadena de controlador correcta depende de si está implementando un controlador de biblioteca de clases o un controlador de conjunto ejecutable.
Aunque puede usar cualquier nombre para su controlador, los nombres de las funciones en C# generalmente están en PascalCase. Además, aunque no es necesario que el nombre del archivo coincida con el nombre de la clase o el nombre del controlador, generalmente se recomienda usar un nombre de archivo como OrderHandler.cs si el nombre de su clase es OrderHandler. Por ejemplo, puede modificar el nombre del archivo en este ejemplo de Function.cs a OrderHandler.cs.
Serialización en C# de las funciones de Lambda
El formato de entrada más común y estándar de las funciones de Lambda es JSON. En este ejemplo, la función espera una entrada similar a la siguiente:
{
"orderId": "12345",
"amount": 199.99,
"item": "Wireless Headphones"
}En C#, puede definir la forma del evento de entrada esperado en una clase. En este ejemplo, definimos la clase Order para modelar esta entrada:
public class Order
{
public string OrderId { get; set; } = string.Empty;
public double Amount { get; set; }
public string Item { get; set; } = string.Empty;
}Si las funciones de Lambda que utilizan tipos de entrada o salida distintos de un objeto Stream, debe agregar una biblioteca de serialización a la aplicación. Esto le permite convertir la entrada JSON en una instancia de la clase que haya definido. Hay dos métodos de serialización para las funciones de C# en Lambda: la serialización basada en la reflexión y la serialización generada por el origen.
Serialización basada en la reflexión
AWS proporciona bibliotecas prediseñadas que puede agregar rápidamente a su aplicación. Estas bibliotecas implementan la serialización mediante reflexión
-
Amazon.Lambda.Serialization.SystemTextJson: en el backend, este paquete usaSystem.Text.Jsonpara efectuar tareas de serialización. -
Amazon.Lambda.Serialization.Json: en el backend, este paquete usaNewtonsoft.Jsonpara efectuar tareas de serialización.
También puede crear su propia biblioteca de serialización mediante la implementación de la interfaz ILambdaSerializer, que está disponible como parte de la biblioteca Amazon.Lambda.Core. Esta interfaz define dos métodos:
-
T Deserialize<T>(Stream requestStream);Puede implementar este método para deserializar la carga de solicitud desde la API
Invokeen el objeto que se pasa al controlador de la función de Lambda. -
T Serialize<T>(T response, Stream responseStream);Puede implementar este método para serializar el resultado que devuelve el controlador de la función de Lambda en la carga de respuesta que devuelve la API de operación
Invoke.
En el ejemplo principal de esta página se usa la serialización basada en la reflexión. La serialización basada en la reflexión funciona de forma inmediata con AWS Lambda y no requiere ninguna configuración adicional, lo que la convierte en una buena opción por su simplicidad. Sin embargo, requiere un mayor uso de memoria de la función. También es posible que vea latencias de funciones más altas debido a la reflexión en tiempo de ejecución.
Serialización generada por el origen
Con la serialización generada por el origen, el código de serialización se genera en tiempo de compilación. Esto elimina la necesidad de reflexión y puede mejorar el rendimiento de la función. Para usar la serialización generada en el origen en la función, haga lo siguiente:
-
Cree una nueva clase parcial que herede de
JsonSerializerContextal añadir atributosJsonSerializablepara todos los tipos que requieran serialización o deserialización. -
Configurar la
LambdaSerializerpara usar unSourceGeneratorLambdaJsonSerializer<T>. -
Actualice cualquier serialización o deserialización manual del código de su aplicación para usar la clase recién creada.
En el siguiente ejemplo se muestra cómo puede modificar el ejemplo principal de esta página, que usa la serialización basada en la reflexión, para usar en su lugar la serialización generada por el origen.
using System.Text.Json;
using System.Text.Json.Serialization;
...
public class Order
{
public string OrderId { get; set; } = string.Empty;
public double Amount { get; set; }
public string Item { get; set; } = string.Empty;
}
[JsonSerializable(typeof(Order))]
public partial class OrderJsonContext : JsonSerializerContext {}
public class OrderHandler
{
...
public async Task<string> HandleRequest(string input, ILambdaContext context)
{
var order = JsonSerializer.Deserialize(input, OrderJsonContext.Default.Order);
...
}
}La serialización generada por el origen requiere más configuración que la serialización basada en la reflexión. Sin embargo, las funciones que usan la serialización generada por el origen suelen usar menos memoria y tienen un mejor rendimiento debido a la generación de código en tiempo de compilación. Para ayudar a eliminar los arranques en frío de las funciones, considere la posibilidad de cambiar a la serialización generada por el origen.
nota
Si desea usar la compilación anticipada (AOT) nativa con Lambda, debe usar la serialización generada por el origen.
Acceso y uso del objeto de contexto de Lambda
El objeto de contexto de Lambda contiene información sobre la invocación, la función y el entorno de ejecución. En este ejemplo, el objeto de contexto es de tipo Amazon.Lambda.Core.ILambdaContext y es el segundo argumento de la función del controlador principal.
public async Task<string> HandleRequest(Order order, ILambdaContext context) {
...
}El objeto de contexto es una entrada opcional. Para obtener más información sobre las firmas de controlador válidas, consulte Firmas de controlador válidas para funciones de C#.
El objeto de contexto es útil para generar registros de funciones en Amazon CloudWatch. Puede usar el método context.getLogger() para obtener un objeto LambdaLogger para el registro. En este ejemplo, podemos usar el registrador para registrar un mensaje de error si el procesamiento falla por cualquier motivo:
context.Logger.LogError($"Failed to process order: {ex.Message}");Además del registro, también puede usar el objeto de contexto para supervisar las funciones. Para obtener más información acerca del objeto de contexto, consulte Uso del objeto de contexto de Lambda para recuperar información de funciones de C#.
Uso de la versión 3 de SDK para .NET en el controlador
A menudo, utilizará las funciones de Lambda para interactuar con otros recursos de AWS o actualizarlos. La forma más sencilla de interactuar con estos recursos es usar la versión 3 de SDK para .NET.
nota
La versión 2 de SDK para .NET se ha quedado obsoleto. Se recomienda que use únicamente la versión 3 de SDK para .NET a partir de ahora.
Puede agregar dependencias del SDK a su proyecto mediante el siguiente comando de Amazon.Lambda.Tools:
dotnet add package<package_name>
Por ejemplo, en el ejemplo principal de esta página, debemos usar la API de Amazon S3 para cargar un recibo en S3. Podemos importar el cliente del SDK de Amazon S3 mediante el siguiente comando:
dotnet add package AWSSDK.S3Este comando agrega la dependencia a su proyecto. Debería ver una línea similar a la siguiente en el archivo .csproj de su proyecto:
<PackageReference Include="AWSSDK.S3" Version="3.7.2.18" />Luego, importe las dependencias directamente en el código de C#:
using Amazon.S3;
using Amazon.S3.Model;El ejemplo de código inicializa un cliente de Amazon S3 (mediante la cadena de proveedores de credenciales predeterminada) de la siguiente manera:
private static readonly AmazonS3Client s3Client = new();En este ejemplo, inicializamos el cliente de Amazon S3 fuera de la función del controlador principal para evitar tener que inicializarlo cada vez que invocamos nuestra función. Después de inicializar el cliente del SDK, podrá usarlo para interactuar con otros servicios de AWS. El código de ejemplo llama a la API PutObject de Amazon S3 de la siguiente manera:
var putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = receiptContent,
ContentType = "text/plain"
};
await s3Client.PutObjectAsync(putRequest);Acceso a las variables de entorno
En el código del controlador, puede hacer referencia a cualquier variable de entorno mediante el método System.Environment.GetEnvironmentVariable. En este ejemplo, se hace referencia a la variable de entorno RECEIPT_BUCKET definida mediante las siguientes líneas de código:
string? bucketName = Environment.GetEnvironmentVariable("RECEIPT_BUCKET");
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new ArgumentException("RECEIPT_BUCKET environment variable is not set");
}Uso del estado global
Lambda ejecuta su código estático y el constructor de clases durante la fase de inicialización antes de invocar la función por primera vez. Los recursos que se crean durante la inicialización permanecen en la memoria entre las invocaciones, por lo que evita tener que crearlos cada vez que invoca la función.
En el código de ejemplo, el código de inicialización del cliente S3 está fuera del método del controlador principal. El tiempo de ejecución inicializa el cliente antes de que la función gestione su primer evento, lo que puede provocar tiempos de procesamiento más largos. Los eventos posteriores son mucho más rápidos porque Lambda no necesita volver a inicializar el cliente.
Simplifique el código de funciones con el marco de anotaciones Lambda
Lambda Annotations
Para ver un ejemplo de una aplicación completa que usa anotaciones de Lambda, consulte el ejemplo de PhotoAssetManagerawsdocs/aws-doc-sdk-examples de GitHub. El archivo Function.cs principal en el directorio PamApiAnnotations usa anotaciones de Lambda. A modo de comparación, el directorio PamApi tiene archivos equivalentes escritos con el modelo de programación normal de Lambda.
Inyección de dependencias con el marco de anotaciones Lambda
También puede utilizar el marco de anotaciones de Lambda para añadir una inyección de dependencias a las funciones de Lambda mediante una sintaxis con la que esté familiarizado. Al añadir un atributo [LambdaStartup] a un archivo Startup.cs, la estructura de anotaciones Lambda generará el código necesario en tiempo de compilación.
[LambdaStartup]
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<IDatabaseRepository, DatabaseRepository>();
}
}La función de Lambda puede inyectar servicios mediante la inyección de un constructor o mediante la inyección en métodos individuales mediante el atributo [FromServices].
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace GetProductHandler;
public class Function
{
private readonly IDatabaseRepository _repo;
public Function(IDatabaseRepository repo)
{
this._repo = repo;
}
[LambdaFunction]
[HttpApi(LambdaHttpMethod.Get, "/product/{id}")]
public async Task<Product> FunctionHandler([FromServices] IDatabaseRepository repository, string id)
{
return await this._repo.GetById(id);
}
}Prácticas recomendadas de codificación para las funciones de Lambda en C#
Siga las directrices de la siguiente lista para utilizar las prácticas recomendadas de codificación al crear sus funciones de Lambda:
-
Separe el controlador de Lambda de la lógica del núcleo. Esto le permite probar las distintas unidades de la función con mayor facilidad.
-
Controle las dependencias del paquete de implementación de la función. El entorno de ejecución AWS Lambda contiene varias bibliotecas. Para disponer del conjunto más reciente de características y actualizaciones de seguridad, Lambda actualizará periódicamente estas bibliotecas. Estas actualizaciones pueden introducir cambios sutiles en el comportamiento de la función de Lambda. Para disponer de un control total de las dependencias que utiliza la función, empaquete todas las dependencias con el paquete de implementación.
-
Minimice la complejidad de las dependencias. Son preferibles los marcos de trabajo más sencillos, ya que se cargan rápidamente al arrancar el entorno de ejecución.
-
Minimice el tamaño del paquete de implementación de acuerdo con las necesidades de su tiempo de ejecución. Esto reducirá la cantidad de tiempo que tarda el paquete de implementación en descargarse y desempaquetarse antes de la invocación. En las funciones creadas en .NET, evite cargar toda la biblioteca del AWS SDK como parte del paquete de implementación. En lugar de ello, cree dependencias selectivas de los módulos que seleccionen los componentes del SDK que necesita (por ejemplo, DynamoDB, módulos del SDK de Amazon S3 y bibliotecas básicas de Lambda).
-
Reutilice el entorno de ejecución para mejorar el rendimiento de la función. Inicialice los clientes de SDK y las conexiones de base de datos fuera del controlador de funciones y almacene localmente en caché los recursos estáticos en el directorio
/tmp. Las invocaciones posteriores procesadas por la misma instancia de su función pueden reutilizar estos recursos. Esto ahorra costes al reducir el tiempo de ejecución de la función.Para evitar posibles filtraciones de datos entre las invocaciones, no utilice el entorno de ejecución para almacenar datos de usuario, eventos u otra información con implicaciones de seguridad. Si su función se basa en un estado mutable que no se puede almacenar en la memoria dentro del controlador, considere crear una función independiente o versiones independientes de una función para cada usuario.
-
Utilice una directiva keep-alive para mantener conexiones persistentes. Lambda purga las conexiones inactivas a lo largo del tiempo. Si intenta reutilizar una conexión inactiva al invocar una función, se producirá un error de conexión. Para mantener la conexión persistente, use la directiva keep-alive asociada al tiempo de ejecución. Para ver un ejemplo, consulte Reutilización de conexiones con Keep-Alive en Node.js.
-
Utilice variables de entorno para pasar parámetros operativos a su función. Por ejemplo, si está escribiendo en un bucket de Amazon S3, en lugar de codificar de forma rígida el nombre del bucket, configúrelo como una variable de entorno.
-
Evite utilizar invocaciones recursivas en la función de Lambda, en las que la función se invoca a sí misma o inicia un proceso que puede volver a invocarla. Esto podría producir un volumen no intencionado de invocaciones de la función y costos elevados. Si observa un volumen imprevisto de invocaciones, establezca la simultaneidad reservada de funciones en
0inmediatamente para limitar todas las invocaciones de la función mientras actualiza el código. -
No utilice API no documentadas y no públicas en el código de la función de Lambda. Para tiempos de ejecución administrados de AWS Lambda, Lambda aplica periódicamente actualizaciones funcionales y de seguridad a las API internas de Lambda. Estas actualizaciones de las API internas pueden ser incompatibles con versiones anteriores, lo que conlleva consecuencias no deseadas, como errores de invocación si su función depende de estas API no públicas. Consulte la referencia de la API para obtener una lista de las API disponibles públicamente.
-
Escriba el código idempotente. Escribir el código idempotente para las funciones garantiza que los eventos duplicados se gestionen de la misma manera. El código debe validar y gestionar correctamente los eventos duplicados. Para obtener más información, consulte ¿Cómo puedo hacer que mi función de Lambda sea idempotente?
.
