Definir o manipulador de função do Lambda em Ruby - AWS Lambda
Conceitos básicos do handler em RubyPráticas recomendadas de código para as funções do Lambda em Ruby

Definir o manipulador de função do Lambda em Ruby

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.

Conceitos básicos do handler em Ruby

No exemplo a seguir, o arquivo function.rb define um método de handler chamado handler. A função do handler usa dois objetos como entrada e retorna um documento JSON.

exemplo function.rb
require 'json'

def handler(event:, context:)
    { event: JSON.generate(event), context: JSON.generate(context.inspect) }
end

Em sua configuração de função, a configuração handler informa o Lambda onde encontrar o manipulador. Para o exemplo anterior, o valor correto para essa configuração é function.handler. Ele inclui dois nomes separados por um ponto: o nome do arquivo e o nome do método do handler.

Você também pode definir o método de handler em uma classe. O exemplo a seguir define um método de handler chamado process em uma classe denominada Handler em um módulo chamado LambdaFunctions.

exemplo source.rb
module LambdaFunctions
  class Handler
    def self.process(event:,context:)
      "Hello!"
    end
  end
end

Nesse caso, a configuração do handler é source.LambdaFunctions::Handler.process.

Os dois objetos que o handler aceita são os eventos de invocação e contexto. O evento é um objeto Ruby que contém a carga que é fornecida pelo chamador. Se a carga útil for um documento JSON, o objeto de evento é um hash do Ruby. Caso contrário, é uma string. O objeto de contexto tem métodos e propriedades que fornecem informações sobre a invocação, a função e o ambiente de execução.

O manipulador da função é executado sempre que sua função do Lambda é invocada. O código estático fora do handler é executado uma vez por instância da função. Se o handler usar recursos como clientes SDK e conexões de banco de dados, você poderá criá-los fora do método de handler para reutilizá-los para várias invocações.

Cada instância de sua função pode processar vários eventos de invocação, mas ela processa apenas um evento por vez. O número de instâncias que processam um evento em um momento é a simultaneidade da sua função. Para obter mais informações sobre o ambiente de execução do Lambda, consulte Entender o ciclo de vida do ambiente de execução do Lambda.

Práticas recomendadas de código para as funções do Lambda em Ruby

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. Por exemplo, em Ruby, isso poderia ser assim: 

    def lambda_handler(event:, context:)
    foo = event['foo']
    bar = event['bar']
    
    result = my_lambda_function(foo:, bar:)

end

def my_lambda_function(foo:, bar:)
    // MyLambdaFunction logic here
    
end

  • 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 o runtime do Ruby, o AWS SDK está incluído. 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 Ruby, evite carregar toda a biblioteca de AWS SDKs como parte do pacote de implantação. Em vez disso, use seletivamente gems que coletem os componentes necessários do SDK (por exemplo, gems do SDK do DynamoDB ou do Amazon S3).

  • 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 0 imediatamente 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?.