O manipulador da função do Lambda é o método no código da função que processa eventos. Quando sua função é invocada, o Lambda executa o método do manipulador. A função é executada até que o manipulador retorne uma resposta, seja encerrado ou atinja o tempo limite.
Esta página descreve como trabalhar com manipuladores de função do Lambda em C# para trabalhar com o runtime gerenciado do .NET, incluindo opções para a configuração de projeto, convenções de nomenclatura e práticas recomendadas. Além disso, esta página apresenta um exemplo de uma função do Lambda em C# que aceita informações sobre um pedido, produz um recibo em formato de texto e armazena esse arquivo em um bucket do Amazon Simple Storage Service (S3). Para obter mais informações sobre como implantar a função após gravá-la, consulte Criar e implantar funções do Lambda em C# com arquivos .zip ou Implantar funções do Lambda em .NET com imagens de contêiner.
Tópicos
Configurar o projeto de manipulador em C#
Ao trabalhar com funções do Lambda em C#, o processo envolve escrever seu código e, em seguida, implantá-lo no Lambda. Há dois modelos de execução diferentes para implantar funções do Lambda no .NET: a abordagem de biblioteca de classes e a abordagem de assembly executável.
Na abordagem de biblioteca de classes, você empacota seu código de função como um assembly .NET (.dll) e o implanta no Lambda com o runtime gerenciado do .NET (dotnet8). Para o nome do manipulador, o Lambda espera uma string no formato AssemblyName::Namespace.Classname::Methodname. Durante a fase de inicialização da função, a classe da função é inicializada e qualquer código no construtor é executado.
Na abordagem de assembly executável, você usa o recurso de instruções de nível superiordotnet8). Para o nome do manipulador, você fornece ao Lambda o nome do assembly executável a ser executado.
O principal exemplo desta página ilustra a abordagem de biblioteca de classes. É possível inicializar seu projeto do Lambda em C# de várias formas, mas a maneira mais fácil é usar a CLI do .NET com a CLI do Amazon.Lambda.Tools. Configure a CLI do Amazon.Lambda.Tools seguindo as etapas em Configurar seu ambiente de desenvolvimento .NET. Em seguida, inicialize o projeto com o comando:
dotnet new lambda.EmptyFunction --name ExampleCSEsse comando gera a seguinte estrutura de arquivos:
/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
Nessa estrutura de arquivos, a lógica do manipulador principal da sua função reside no arquivo Function.cs.
Exemplo de código de função do Lambda em C#
O exemplo de código apresentado a seguir para uma função do Lambda em C# aceita informações sobre um pedido, produz um recibo em formato de texto e armazena esse arquivo em um bucket do Amazon S3.
exemplo Função do Lambda em 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 arquivo Function.cs contém as seguintes seções de código:
-
Declarações de
using: use-as para importar as classes C# exigidas por sua função do Lambda. -
[assembly: LambdaSerializer(...)]:LambdaSerializeré um atributo de assembly que informa ao Lambda para converter automaticamente as cargas úteis de eventos JSON em objetos C# antes de passá-las para sua função. -
namespace ExampleLambda: define o namespace. Em C#, o nome do namespace não precisa corresponder ao nome do arquivo. -
public class Order {...}: define o formato do evento de entrada esperado. -
public class OrderHandler {...}: define sua classe C#. Aqui você definirá o método principal do manipulador e quaisquer outros métodos auxiliares. -
private static readonly AmazonS3Client s3Client = new();: inicializa um cliente do Amazon S3 com a cadeia de provedores de credenciais padrão, fora do método do manipulador principal. Isso faz com que o Lambda execute esse código durante a fase de inicialização. -
public async ... HandleRequest (Order order, ILambdaContext context): este é o método principal do manipulador, que contém a lógica principal da sua aplicação. -
private async Task UploadReceiptToS3(...) {}: este é um método auxiliar que é referenciado pelo método principal do manipuladorhandleRequest.
Como essa função requer um cliente do Amazon S3 SDK, você deve adicioná-lo às dependências do seu projeto. Você pode fazer isso navegando até src/ExampleCS e executando o seguinte comando:
dotnet add package AWSSDK.S3Por padrão, o arquivo aws-lambda-tools-defaults.json gerado não contém informações profile ou region para sua função. Além disso, atualize a string function-handler com o valor correto (ExampleCS::ExampleLambda.OrderHandler::HandleRequest). Você pode fazer essa atualização manualmente e adicionar os metadados necessários para usar um perfil de credenciais e uma região específicos para sua função. Por exemplo, seu arquivo aws-lambda-tools-defaults.json deve ser semelhante a este:
{
"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 função funcione corretamente, seu perfil de execução deve permitir a ação s3:PutObject. Se usar o comando dotnet lambda deploy-function (ou seja, dotnet lambda deploy-function ExampleCS), a política AWSLambdaExecute nos prompts da CLI conterá as permissões necessárias para você invocar essa função com êxito.
Além disso, certifique-se de que
Finalmente, certifique-se de definir a variável de ambiente RECEIPT_BUCKET. Após uma invocação com êxito, o bucket do Amazon S3 deve conter um arquivo de recibo.
Manipuladores de bibliotecas de classes
O principal exemplo de código desta página ilustra um manipulador de biblioteca de classes. Os manipuladores de biblioteca de classes têm a seguinte estrutura:
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace NAMESPACE;
...
public class CLASSNAME {
public async Task<string> METHODNAME (...) {
...
}
}Ao criar uma função do Lambda, você precisa fornecer ao Lambda informações sobre o manipulador da função na forma de uma string no campo Manipulador. Isso informa ao Lambda qual método do código deve ser executado quando sua função é invocada. Em C#, para manipuladores de bibliotecas de classes, o formato da string do manipulador é ASSEMBLY::TYPE::METHOD, onde:
-
ASSEMBLYé o nome do arquivo de assembly do .NET para a aplicação. Se você usar a CLI doAmazon.Lambda.Toolspara criar a aplicação e não definir o nome do assembly usando a propriedadeAssemblyNameno arquivo.csproj,ASSEMBLYserá simplesmente o nome do arquivo.csproj. -
TYPEé o nome completo do tipo do manipulador, ou seja,NAMESPACE.CLASSNAME. -
METHODé o nome do método do manipulador principal no código, ou seja,METHODNAME.
Para o código de exemplo principal nesta página, se o assembly for denominado ExampleCS, a string completa do manipulador será ExampleCS::ExampleLambda.OrderHandler::HandleRequest.
Manipuladores de assembly executáveis
Também é possível definir funções do Lambda em C# como um assembly executável. Os manipuladores de assembly executáveis utilizam o recurso de instruções de nível superior do C#, no qual o compilador gera o método Main() e coloca o código da sua função dentro dele. Ao usar assemblies executáveis, o runtime do Lambda deve ser inicializado. Para fazer isso, use o método LambdaBootstrapBuilder.Create no código. As entradas para este método são a função do manipulador principal, bem como o serializador do Lambda a ser usado. O seguinte exemplo mostra um manipulador de assembly executável em 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)
};
};No campo Manipulador para manipuladores de assemblies executáveis, a string do manipulador que diz ao Lambda como executar seu código é o nome do assembly. Nesse exemplo, é GetProductHandler.
Assinaturas de manipulador válidas para funções em C#
Em C#, as assinaturas de manipulador do Lambda válidas aceitam entre 0 e 2 argumentos. Normalmente, sua assinatura de manipulador tem dois argumentos, conforme mostrado no exemplo principal:
public async Task<string> HandleRequest(Order order, ILambdaContext context)Ao fornecer dois argumentos, o primeiro argumento deve ser a entrada do evento e o segundo argumento deve ser o objeto de contexto do Lambda. Ambos os argumentos são opcionais. Por exemplo, as seguintes também são assinaturas válidas do manipulador do Lambda em C#:
-
public async Task<string> HandleRequest() -
public async Task<string> HandleRequest(Order order) -
public async Task<string> HandleRequest(ILambdaContext context)
Além da sintaxe básica da assinatura do manipulador, há algumas restrições adicionais:
-
Não é possível usar a palavra-chave
unsafena assinatura do manipulador. No entanto, é possível usar o contextounsafedentro do método manipulador e suas dependências. Para obter mais informações, consulte unsafe (referência de C#)no site de documentação da Microsoft. -
O manipulador não pode usar a palavra-chave
paramsnem usarArgIteratorcomo parâmetro de entrada ou retorno. Essas palavras-chave oferecem suporte a um número variável de parâmetros. O número máximo de argumentos que seu manipulador pode aceitar é dois. -
O manipulador não pode ser um método genérico. Em outras palavras, ele não pode usar parâmetros de tipo genérico, como
<T>. -
O Lambda não oferece suporte a manipuladores assíncronos com
async voidna assinatura.
Convenções de nomenclatura para manipuladores
Os manipuladores do Lambda em C# não têm restrições estritas de nomenclatura. No entanto, é necessário garantir que você forneça a string correta do manipulador ao Lambda ao implantar a função. A string correta do manipulador depende se você está implantando um manipulador de biblioteca de classes ou um manipulador de montagem executável.
Apesar de ser possível usar um nome qualquer para o manipulador, os nomes das funções em C# geralmente estão em PascalCase. Além disso, embora o nome do arquivo não precise corresponder ao nome da classe ou do manipulador, geralmente é prática recomendada usar um nome de arquivo como OrderHandler.cs se o nome da classe for OrderHandler. Por exemplo, é possível modificar o nome do arquivo neste exemplo de Function.cs para OrderHandler.cs.
Serialização em funções do Lambda em C#
O formato de entrada JSON é o mais comum e padrão para funções do Lambda. Neste exemplo, a função espera uma entrada semelhante à seguinte:
{
"orderId": "12345",
"amount": 199.99,
"item": "Wireless Headphones"
}Em C#, é possível definir o formato do evento de entrada esperado em uma classe. Neste exemplo, definimos a classe Order para modelar essa entrada:
public class Order
{
public string OrderId { get; set; } = string.Empty;
public double Amount { get; set; }
public string Item { get; set; } = string.Empty;
}Se a função do Lambda usar tipos de entrada ou de saída diferentes de objeto Stream, você deverá adicionar uma biblioteca de serialização à aplicação. Isso permite converter a entrada JSON em uma instância da classe que você definiu. Há dois métodos de serialização para funções em C# no Lambda: serialização baseada em reflexão e serialização gerada por código-fonte.
Serialização baseada em reflexão
A AWS fornece bibliotecas pré-criadas que você pode adicionar rapidamente à aplicação. Essas bibliotecas implementam a serialização usando reflexão
-
Amazon.Lambda.Serialization.SystemTextJson: no backend, esse pacote usaSystem.Text.Jsonpara realizar tarefas de serialização. -
Amazon.Lambda.Serialization.Json: no backend, esse pacote usaNewtonsoft.Jsonpara realizar tarefas de serialização.
Você pode criar sua própria biblioteca de serialização implementando a interface ILambdaSerializer, que está disponível como parte da biblioteca Amazon.Lambda.Core. Essa interface define dois métodos:
-
T Deserialize<T>(Stream requestStream);Você implementa esse método para desserializar a carga útil da solicitação da API
Invokeno objeto que é passado para o manipulador da função do Lambda. -
T Serialize<T>(T response, Stream responseStream);Você implementa esse método para serializar o resultado retornado pelo manipulador da função do Lambda na carga útil da resposta retornada pela operação da API
Invoke.
O exemplo principal nesta página usa serialização baseada em reflexão. A serialização baseada em reflexão funciona imediatamente com o AWS Lambda e não requer configuração adicional, o que a torna uma boa opção para simplificação. No entanto, ela requer mais uso da memória funcional. Você também pode ver latências de função mais altas devido à reflexão do runtime.
Serialização gerada por código-fonte
Com a serialização gerada por código-fonte, o código de serialização é gerado em tempo de compilação. Isso elimina a necessidade de reflexão e pode melhorar a performance da função. Para usar a serialização gerada por código-fonte na função, é necessário fazer o seguinte:
-
Crie uma nova classe parcial herdada de
JsonSerializerContext, adicionando atributosJsonSerializablepara todos os tipos que exigem serialização ou desserialização. -
Configure o
LambdaSerializerpara usar umSourceGeneratorLambdaJsonSerializer<T>. -
Atualize qualquer serialização ou desserialização manual no código da aplicação para usar a classe recém-criada.
O exemplo a seguir mostra como você pode modificar o exemplo principal nesta página, que usa serialização baseada em reflexão, para usar a serialização gerada por código-fonte.
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);
...
}
}A serialização gerada por código-fonte requer mais configuração do que a serialização baseada em reflexão. No entanto, as funções que usam a serialização gerada por código-fonte tendem a usar menos memória e apresentar maior performance devido à geração de código em tempo de compilação. Para ajudar a eliminar as inicializações a frio de funções, considere migrar para a serialização gerada por código-fonte.
nota
Caso deseje usar a compilação antecipada (AOT) nativa com o Lambda, será necessário usar a serialização gerada por código-fonte.
Acesso e uso do objeto de contexto do Lambda
O objeto de contexto do Lambda contém informações sobre a invocação, a função e o ambiente de execução. Neste exemplo, o objeto de contexto é do tipo Amazon.Lambda.Core.ILambdaContext e é o segundo argumento da função principal do manipulador.
public async Task<string> HandleRequest(Order order, ILambdaContext context) {
...
}O objeto de contexto é uma entrada opcional. Para obter mais informações sobre as assinaturas de manipulador válidas e aceitas, consulte Assinaturas de manipulador válidas para funções em C#.
O objeto de contexto é útil para produzir logs de funções para o Amazon CloudWatch. É possível usar o método context.getLogger() para obter um objeto LambdaLogger para registro. Neste exemplo, podemos usar o logger para registrar uma mensagem de erro se o processamento falhar por qualquer motivo:
context.Logger.LogError($"Failed to process order: {ex.Message}");Fora do registro em log, é possível usar o objeto de contexto para realizar o monitoramento da função. Para obter mais informações sobre o objeto de contexto, consulte Usar o objeto de contexto do Lambda para recuperar informações das funções em C#.
Uso do SDK para .NET v3 em seu manipulador
Frequentemente, você usará as funções do Lambda para interagir com ou fazer atualizações em outros recursos da AWS. A maneira mais simples de interagir com esses recursos é usar o SDK para .NET v3.
nota
O SDK para .NET (v2) está obsoleto. Recomendamos usar somente o SDK para .NET v3 daqui em diante.
Você pode adicionar dependências do SDK ao seu projeto usando o seguinte comando do Amazon.Lambda.Tools:
dotnet add package<package_name>
Por exemplo, no exemplo principal nesta página, precisamos usar a API do Amazon S3 para fazer upload de um recibo no S3. Podemos importar o cliente do Amazon S3 SDK com o seguinte comando:
dotnet add package AWSSDK.S3Esse comando adiciona a dependência ao seu projeto. Você também deve ver uma linha semelhante à seguinte no arquivo .csproj do seu projeto:
<PackageReference Include="AWSSDK.S3" Version="3.7.2.18" />Em seguida, importe as dependências diretamente em seu código C#:
using Amazon.S3;
using Amazon.S3.Model;O código de exemplo então inicializa um cliente do Amazon S3 (usando a cadeia de fornecedores de credenciais padrão) da seguinte forma:
private static readonly AmazonS3Client s3Client = new();Neste exemplo, inicializamos nosso cliente do Amazon S3 fora da função do manipulador principal para evitar a necessidade que inicializá-lo a cada vez que nossa função é invocada. Após inicializar o cliente do SDK, você pode usá-lo para interagir com outros serviços da AWS. O código de exemplo chama a API PutObject do Amazon S3 da seguinte forma:
var putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = receiptContent,
ContentType = "text/plain"
};
await s3Client.PutObjectAsync(putRequest);Acesso a variáveis de ambiente
No código do manipulador, é possível fazer referência a qualquer variável de ambiente ao usar o método System.Environment.GetEnvironmentVariable. Neste exemplo, referenciamos a variável de ambiente RECEIPT_BUCKET definida usando as seguintes linhas de código:
string? bucketName = Environment.GetEnvironmentVariable("RECEIPT_BUCKET");
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new ArgumentException("RECEIPT_BUCKET environment variable is not set");
}Usar o estado global
O Lambda executa seu código estático e o construtor de classe durante a fase de inicialização antes de invocar a função pela primeira vez. Os recursos criados durante a inicialização permanecem na memória entre as invocações, para que você possa evitar ter que criá-los toda vez que invocar sua função.
No código de exemplo, o código de inicialização do cliente do S3 está fora do método do manipulador principal. O runtime inicializa o cliente antes que a função manipule seu primeiro evento, o que pode levar a tempos de processamento mais longos. Os eventos subsequentes são muito mais rápidos porque o Lambda não precisa inicializar o cliente novamente.
Simplificar o código da função com a estrutura Lambda Annotations
O Lambda Annotations
Para ver um exemplo de uma aplicação completa que utiliza o Lambda Annotations, consulte o exemplo PhotoAssetManagerawsdocs/aws-doc-sdk-examples do GitHub. O arquivo Function.cs principal no diretório PamApiAnnotations usa o Lambda Annotations. Para comparação, o diretório PamApi tem arquivos equivalentes escritos usando o modelo de programação do Lambda normal.
Injeção de dependência com a estrutura Lambda Annotations
Você também pode usar a estrutura do Lambda Annotations para adicionar injeção de dependência nas funções do Lambda usando a sintaxe com a qual você está familiarizado. Quando você adiciona um atributo [LambdaStartup] a um arquivo Startup.cs, a estrutura do Lambda Annotations gera o código necessário durante a compilação.
[LambdaStartup]
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<IDatabaseRepository, DatabaseRepository>();
}
}A função Lambda pode injetar serviços usando injeção de construtor ou injetando em métodos individuais usando o 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áticas recomendadas de código para as funções do Lambda em C#
Adote as diretrizes da lista a seguir para usar as práticas recomendadas de codificação ao compilar suas funções do Lambda:
-
Separe o manipulador do Lambda da lógica central. Isso permite que você crie uma função mais fácil para teste de unidade.
-
Controle as dependências no pacote de implantação da função. O ambiente de execução do AWS Lambda contém várias bibliotecas. Para habilitar o conjunto de recursos e atualizações de segurança mais recente, o Lambda atualizará periodicamente essas bibliotecas. Essas atualizações podem introduzir alterações sutis ao comportamento de sua função do Lambda. Para ter controle total das dependências usadas por sua função, empacote todas as dependências em seu pacote de implantação.
-
Minimize a complexidade de suas dependências. Prefira frameworks mais simples que sejam carregados rapidamente no startup do ambiente de execução.
-
Minimize o tamanho do pacote de implantação às necessidades do runtime. Isso reduzirá a quantidade de tempo necessária para que seu pacote de implantação seja obtido por download e desempacotado antes da invocação. Para funções criadas em .NET Core, evite carregar toda a biblioteca do AWS SDK como parte do pacote de implantação. Em vez disso, dependa seletivamente dos módulos que coletam os componentes do SDK necessários (por exemplo, DynamoDB, módulos do SDK do Amazon S3 e bibliotecas principais do Lambda).
-
Aproveite a reutilização do ambiente de execução para melhorar a performance da função. Inicialize clientes SDK e conexões de banco de dados fora do manipulador de funções e armazene em cache os ativos estáticos localmente no diretório
/tmp. As invocações subsequentes processadas pela mesma instância da função podem reutilizar esses recursos. Isso economiza custos reduzindo o runtime da função.Para evitar possíveis vazamentos de dados entre invocações, não use o ambiente de execução para armazenar dados do usuário, eventos ou outras informações com implicações de segurança. Se sua função depende de um estado mutável que não pode ser armazenado na memória dentro do manipulador, considere criar uma função separada ou versões separadas de uma função para cada usuário.
-
Use uma diretiva de keep-alive para manter conexões persistentes. O Lambda limpa conexões ociosas ao longo do tempo. A tentativa de reutilizar uma conexão ociosa ao invocar uma função resultará em um erro de conexão. Para manter sua conexão persistente, use a diretiva keep-alive associada ao runtime. Para obter um exemplo, consulte Reutilizar conexões com keep-alive em Node.js.
-
Use variáveis de ambiente para passar parâmetros operacionais para sua função. Por exemplo, se estiver gravando em um bucket do Amazon S3, em vez fixar no código o nome do bucket em que você está gravando, configure o nome do bucket como uma variável de ambiente.
-
Evite usar invocações recursivas em sua função do Lambda, em que a função invoca a si mesma ou inicia um processo que pode invocar a função novamente. Isso pode levar a um volume não intencional de invocações da função e a custos elevados. Se você observar um volume não intencional de invocações, defina a simultaneidade reservada da função como
0imediatamente para limitar todas as invocações da função enquanto atualiza o código. -
Não use APIs não documentadas e não públicas no código da função Lambda. Para os tempos de execução gerenciados pelo AWS Lambda, o Lambda aplica periodicamente atualizações funcionais e de segurança às APIs internas do Lambda. Essas atualizações internas da API podem ser incompatíveis com versões anteriores, gerando consequências não intencionais, como falhas de invocação, caso sua função tenha dependência nessas APIs não públicas. Consulte a referência da API para obter uma lista de APIs disponíveis publicamente.
-
Escreva um código idempotente. Escrever um código idempotente para suas funções garante que eventos duplicados sejam tratados da mesma maneira. Seu código deve validar eventos adequadamente e lidar corretamente com eventos duplicados. Para obter mais informações, consulte Como torno minha função do Lambda idempotente?
.
