Definir el controlador de la función de Lambda en Ruby

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.

Concepts básicos del controlador de Ruby

En el siguiente ejemplo, el archivo function.rb define un método de controlador llamado handler. La función de controlador tiene dos objetos como entrada y devuelve un documento JSON.

ejemplo function.rb

require 'json'

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

En su configuración de la función, el valor handler indica a Lambda dónde encontrar el controlador. Para el ejemplo anterior, el valor correcto para este valor es function.handler. Incluye dos nombres separados por un punto: el nombre del archivo y el nombre del método del controlador.

También puede definir su método de controlador en una clase. En el siguiente ejemplo se define un método de controlador llamado process en una clase llamada Handler en un módulo llamado LambdaFunctions.

ejemplo source.rb

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

En este caso, el valor del controlador es source.LambdaFunctions::Handler.process.

Los dos objetos que el controlador acepta son el evento de invocación y el contexto. El evento es un objeto Ruby que contiene la carga que proporciona el invocador. Si la carga es un documento JSON, el objeto de evento es un hash de Ruby. De lo contrario, es una cadena. Este objeto de contexto tiene métodos y propiedades que facilitan información acerca de la invocación, la función y el entorno de ejecución.

El controlador de la función se ejecuta cada vez que se invoca la función de Lambda. El código estático fuera del controlador se ejecuta una vez por instancia de la función. Si su controlador utiliza recursos como clientes de SDK y conexiones de bases de datos, puede crearlos fuera del método de controlador para volver a utilizarlos en varias invocaciones.

Cada instancia de la función permite procesar varios eventos de invocación, pero solo procesa un evento cada vez. El número de instancias que procesan un evento en un momento dado es la simultaneidad de la función. Para obtener más información acerca del entorno de ejecución de Lambda, consulte Comprender el ciclo de vida del entorno de ejecución de Lambda.

Prácticas recomendadas de codificación para las funciones de Lambda en Ruby

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. Por ejemplo, en Ruby, podría tener este aspecto:

  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 las dependencias del paquete de implementación de la función. El entorno de ejecución AWS Lambda contiene varias bibliotecas. En el caso del entorno de ejecución de Ruby, estas incluyen el SDK de AWS. 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 Ruby, evite cargar toda la biblioteca de SDK de AWS como parte del paquete de implementación. En lugar de ello, cree dependencias selectivas de las gemas que seleccionen los componentes del SDK que necesita (por ejemplo, las gemas de SDK de Amazon S3 o DynamoDB).

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