# Creación de funciones de Lambda con Ruby
Puede ejecutar código Ruby en AWS Lambda. Lambda ofrece [tiempos de ejecución](lambda-runtimes.md) para Ruby que ejecutan código para procesar eventos. El código se ejecuta en un entorno que incluye AWS SDK para Ruby, con credenciales de un rol de AWS Identity and Access Management (IAM) que usted administre. Para obtener más información sobre las versiones del SDK incluidas en los tiempos de ejecución de Ruby, consulte [Versiones del SDK incluidas en el tiempo de ejecución](#ruby-sdk-included).
Lambda admite los siguientes entornos de tiempos de ejecución de Ruby.
| Nombre | Identificador | Sistema operativo | Fecha de baja | Bloqueo de la función Crear | Bloqueo de la función Actualizar |
| --- | --- | --- | --- | --- | --- |
| Ruby 3.4 | `ruby3.4` | Amazon Linux 2023 | 31 de marzo de 2028 | 30 de abril de 2028 | 31 de mayo de 2028 |
| Ruby 3.3 | `ruby3.3` | Amazon Linux 2023 | 31 de marzo de 2027 | 30 de abril de 2027 | 31 de mayo de 2027 |
| Ruby 3.2 | `ruby3.2` | Amazon Linux 2 | 31 de marzo de 2026 | 31 de agosto de 2026 | 30 de septiembre de 2026 |
**Para crear una función Ruby**
1. Abra la [consola de Lambda](https://console.aws.amazon.com/lambda).
1. Seleccione **Creación de función**.
1. Configure los siguientes ajustes:
+ En **Nombre de la función**: ingrese el nombre de la función.
+ **Tiempo de ejecución**: elija **Ruby 3.4**.
1. Elija **Crear función**.
La consola crea una función de Lambda con un único archivo de origen llamado `lambda_function.rb`. Puede editar este archivo y agregar más archivos en el editor de código integrado. En la sección **IMPLEMENTAR**, elija **Implementar** para actualizar el código de la función. A continuación, para ejecutar el código, seleccione **Crear evento de prueba** en la sección **EVENTOS DE PRUEBA**.
El archivo `lambda_function.rb` exporta una función denominada `lambda_handler` que toma un objeto de evento y un objeto context. Esta es la [función de controlador](ruby-handler.md) a la que llama Lambda cuando se invoca la función. El tiempo de ejecución de la función de Ruby obtiene eventos de Lambda y los pasa al controlador. En la configuración de función, el valor de controlador es `lambda_function.lambda_handler`.
Al guardar el código de función, la consola de Lambda crea un paquete de implementación de archivo .zip. Cuando desarrolle el código de función fuera de la consola (mediante un IDE), debe [crear un paquete de implementación](ruby-package.md) para cargar el código a la función de Lambda.
El tiempo de ejecución de la función pasa un objeto context al controlador, además del evento de invocación. El [objeto context](ruby-context.md) contiene información adicional acerca de la invocación, la función y el entorno de ejecución. Hay más información disponible en las variables de entorno.
Su función de Lambda tiene un grupo de registros de Registros de CloudWatch. El tiempo de ejecución de la función envía detalles de cada invocación a Registros de CloudWatch. Se transmite cualquier [registro que su función genere](ruby-logging.md) durante la invocación. Si su función devuelve un error, Lambda formatea el error y lo devuelve al invocador.
**Topics**
+ [
## Versiones del SDK incluidas en el tiempo de ejecución
](#ruby-sdk-included)
+ [
## Habilitación de otro JIT de Ruby (YJIT)
](#ruby-yjit)
+ [
# Definir el controlador de la función de Lambda en Ruby
](ruby-handler.md)
+ [
# Implementar funciones de Lambda de Ruby con archivos .zip
](ruby-package.md)
+ [
# Implementación de funciones de Lambda de Ruby con imágenes de contenedor
](ruby-image.md)
+ [
# Uso de capas para funciones de Lambda en Ruby
](ruby-layers.md)
+ [
# Uso del objeto de contexto Lambda para recuperar la información de la función de Ruby
](ruby-context.md)
+ [
# Registro y supervisión de las funciones de Lambda
](ruby-logging.md)
+ [
# Instrumentación del código Ruby en AWS Lambda
](ruby-tracing.md)
## Versiones del SDK incluidas en el tiempo de ejecución
La versión del AWS SDK incluida en el tiempo de ejecución de Ruby depende de la versión del tiempo de ejecución y de su Región de AWS. AWS SDK para Ruby está diseñado para ser modular y está separado por Servicio de AWS. Para encontrar el número de versión de una gema de servicio concreta incluida en el tiempo de ejecución que está utilizando, cree una función de Lambda con código en el siguiente formato. Sustituya `aws-sdk-s3` y `Aws::S3` por el nombre de las gemas de servicio que utilice su código.
```
require 'aws-sdk-s3'
def lambda_handler(event:, context:)
puts "Service gem version: #{Aws::S3::GEM_VERSION}"
puts "Core version: #{Aws::CORE_GEM_VERSION}"
end
```
## Habilitación de otro JIT de Ruby (YJIT)
Los tiempos de ejecución de Ruby admiten [YJIT](https://docs.ruby-lang.org/en/master/jit/yjit_md.html), un compilador JIT de Ruby ligero y minimalista. YJIT proporciona un rendimiento significativamente mayor, pero también utiliza más memoria que el intérprete de Ruby. Se recomienda YJIT para cargas de trabajo de Ruby on Rails.
YJIT no está habilitado de forma predeterminada. Para habilitar YJIT para una función de Ruby, configure la variable de entorno `RUBY_YJIT_ENABLE` en `1`. Para confirmar que YJIT está habilitado, imprima el resultado del método `RubyVM::YJIT.enabled?`.
**Example — Confirme que YJIT está habilitado**
```
puts(RubyVM::YJIT.enabled?())
# => true
```
# 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.
**Topics**
+ [
## Concepts básicos del controlador de Ruby
](#ruby-handler-basics)
+ [
## Prácticas recomendadas de codificación para las funciones de Lambda en Ruby
](#ruby-best-practices)
## 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.
**Example 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`.
**Example 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](ruby-context.md) 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](lambda-runtime-environment.md).
## 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](lambda-runtime-environment.md).
+ **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](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).
**Utilice [variables de entorno](configuration-envvars.md) 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](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) 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?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).
# Implementar funciones de Lambda de Ruby con archivos .zip
El código de la función de AWS Lambda incluye un archivo .rb que contiene el código del controlador de la función, junto con las dependencias adicionales (gemas) de las que dependa el código. Para implementar este código de función en Lambda, se utiliza un *paquete de despliegue*. Este paquete puede ser un archivo de archivos .zip o una imagen de contenedor. Para obtener más información sobre el uso de imágenes de contenedores con Ruby, consulte [Implementar funciones de Lambda Ruby con imágenes de contenedores](https://docs.aws.amazon.com/lambda/latest/dg/ruby-image.html).
Para crear un paquete de despliegue como un archivo de archivos .zip, puede emplear utilidad de archivado de archivos .zip incorporada de la herramienta de línea de comandos, o cualquier otra utilidad de archivos .zip, como [7zip](https://www.7-zip.org/download.html). En los ejemplos que se muestran en las siguientes secciones se supone que está utilizando una herramienta `zip` de línea de comandos en un entorno Linux o macOS. Para utilizar los mismos comandos en Windows, puede [instalar el Subsistema de Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) a fin de obtener una versión de Ubuntu y Bash integrada con Windows.
Tenga en cuenta que Lambda utiliza permisos de archivo de POSIX, por lo que puede necesitar [establecer permisos para la carpeta del paquete de despliegue](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) antes de crear el archivo de archivos .zip.
En los comandos de ejemplo de las siguientes secciones, se utiliza la utilidad [Agrupador](https://bundler.io/) para agregar dependencias al paquete de despliegue. Ejecute el siguiente comando para instalar el agrupador.
```
gem install bundler
```
**Topics**
+ [
## Dependencias en Ruby
](#ruby-package-runtime-dependencies)
+ [
## Creación de un paquete de despliegue .zip sin dependencias
](#ruby-package-codeonly)
+ [
## Creación de un paquete de despliegue .zip con dependencias
](#ruby-package-dependencies)
+ [
## Creación de una capa de Ruby para las dependencias
](#ruby-package-dependencies-layers)
+ [
## Creación de paquetes de despliegue .zip con bibliotecas nativas
](#ruby-package-native)
+ [
## Creación y actualización de funciones de Lambda Ruby mediante archivos .zip
](#ruby-package-create-functions)
## Dependencias en Ruby
Para las funciones de Lambda que utilizan el tiempo de ejecución de Ruby, una dependencia puede ser cualquier gema de Ruby. Cuando implemente la función mediante un archivo .zip, podrá agregar estas dependencias a su archivo .zip con el código de la función o utilizar una capa de Lambda. Una capa es un archivo .zip independiente que puede contener código adicional y otro contenido. Para obtener más información sobre el uso de las capas de Lambda, consulte [Administración de las dependencias de Lambda con capas](chapter-layers.md).
En el tiempo de ejecución de Ruby se incluye el AWS SDK para Ruby. Si la función utiliza el SDK, no necesita agruparlo con el código. Sin embargo, para mantener el control total de las dependencias o para utilizar una versión específica del SDK, puede agregarla al paquete de despliegue de la función. Puede incluir el SDK en el archivo .zip o agregarlo mediante una capa de Lambda. Las dependencias del archivo .zip o de las capas de Lambda tienen prioridad sobre las versiones incluidas en el tiempo de ejecución. Para saber qué versión del SDK para Ruby está incluida en la versión del tiempo de ejecución, consulte [Versiones del SDK incluidas en el tiempo de ejecución](lambda-ruby.md#ruby-sdk-included).
Según el [modelo de responsabilidad compartida de AWS](lambda-runtimes.md#runtimes-shared-responsibility), usted es responsable de la administración de cualquier dependencia en los paquetes de despliegue de sus funciones. Esto incluye la aplicación de actualizaciones y parches de seguridad. Para actualizar las dependencias del paquete de despliegue de la función, primero cree un nuevo archivo .zip y, a continuación, cárguelo en Lambda. Para obtener más información, consulte [Creación de un paquete de despliegue .zip con dependencias](#ruby-package-dependencies) y [Creación y actualización de funciones de Lambda Ruby mediante archivos .zip](#ruby-package-create-functions).
## Creación de un paquete de despliegue .zip sin dependencias
Si el código de la función no tiene dependencias, el archivo .zip solo contiene el archivo .rb con el código del controlador de la función. Utilice la utilidad de compresión que prefiera para crear un archivo .zip con el archivo .rb en la raíz. Si el archivo .rb no está en la raíz del archivo .zip, Lambda no podrá ejecutar el código.
Para obtener información sobre cómo implementar un archivo .zip para crear una nueva función de Lambda o actualizar una existente, consulte [Creación y actualización de funciones de Lambda Ruby mediante archivos .zip](#ruby-package-create-functions).
## Creación de un paquete de despliegue .zip con dependencias
Si el código de la función depende de gemas de Ruby adicionales, puede agregar estas dependencias al archivo .zip con el código de la función o utilizar una [capa de Lambda](chapter-layers.md). En las instrucciones de esta sección, se muestra cómo incluir las dependencias en el paquete de despliegue .zip. Para obtener instrucciones sobre cómo incluir las dependencias en una capa, consulte [Creación de una capa de Ruby para las dependencias](#ruby-package-dependencies-layers).
Supongamos que el código de la función se guarda en un archivo llamado `lambda_function.rb` del directorio del proyecto. Los siguientes comandos de la CLI crean un archivo .zip llamado `my_deployment_package.zip` que contiene el código de la función de y sus dependencias.
**Creación del paquete de implementación**
1. En el directorio del proyecto, cree un `Gemfile` para especificar las dependencias.
```
bundle init
```
1. Con el editor de texto que prefiera, edite el `Gemfile` para especificar las dependencias de la función. Por ejemplo, para utilizar la gema TZInfo, edite el `Gemfile` para que tenga una apariencia similar a la siguiente.
```
source "https://rubygems.org"
gem "tzinfo"
```
1. Ejecute el siguiente comando para instalar las gemas especificadas en el `Gemfile` del directorio del proyecto. Este comando configura `vendor/bundle` como la ruta predeterminada para las instalaciones de gemas.
```
bundle config set --local path 'vendor/bundle' && bundle install
```
Debería ver un resultado similar a este.
```
Fetching gem metadata from https://rubygems.org/...........
Resolving dependencies...
Using bundler 2.4.13
Fetching tzinfo 2.0.6
Installing tzinfo 2.0.6
...
```
**nota**
Para volver a instalar gemas a nivel global más adelante, ejecute el siguiente comando.
```
bundle config set --local system 'true'
```
1. Cree un archivo .zip que contenga el archivo `lambda_function.rb` con el código del controlador de la función y las dependencias que instaló en el paso anterior.
```
zip -r my_deployment_package.zip lambda_function.rb vendor
```
Debería ver un resultado similar a este.
```
adding: lambda_function.rb (deflated 37%)
adding: vendor/ (stored 0%)
adding: vendor/bundle/ (stored 0%)
adding: vendor/bundle/ruby/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/build_info/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/cache/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/cache/aws-eventstream-1.0.1.gem (deflated 36%)
...
```
## Creación de una capa de Ruby para las dependencias
Para aprender a empaquetar las dependencias de Ruby en una capa Lambda, consulte [Uso de capas para funciones de Lambda en Ruby](ruby-layers.md).
## Creación de paquetes de despliegue .zip con bibliotecas nativas
Muchas gemas de Ruby comunes, como `nokogiri`, `nio4r` y `mysql`, contienen extensiones nativas escritas en C. Cuando agregue bibliotecas que contienen código C al paquete de despliegue, deberá compilar el paquete correctamente para garantizar que sea compatible con el entorno de ejecución de Lambda.
Para las aplicaciones de producción, recomendamos crear e implementar el código mediante AWS Serverless Application Model (AWS SAM). En AWS SAM, utilice la opción `sam build --use-container` para crear la función dentro de un contenedor de Docker tipo Lambda. Para obtener más información sobre el uso de AWS SAM para implementar el código de la función, consulte [Creación de aplicaciones](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-using-build.html) en la *Guía para desarrolladores de AWS SAM*.
Para crear un paquete de despliegue .zip que contenga gemas con extensiones nativas sin utilizar AWS SAM, también puede utilizar un contenedor para agrupar las dependencias en un entorno que sea igual al entorno de tiempo de ejecución de Ruby Lambda. Para completar estos pasos, debe tener Docker instalado en su equipo de compilación. Para obtener más información sobre la instalación de Docker, consulte [Instalar Docker Engine](https://docs.docker.com/engine/install/).
**Para crear un paquete de despliegue .zip en un contenedor de Docker**
1. Cree una carpeta en el equipo de compilación local para guardar el contenedor. Dentro de esa carpeta, cree un archivo llamado `dockerfile` y pegue el siguiente código en él.
```
FROM public.ecr.aws/sam/build-ruby3.2:latest-x86_64
RUN gem update bundler
CMD "/bin/bash"
```
1. Dentro de la carpeta en la que creó el `dockerfile`, ejecute el siguiente comando para crear el contenedor de Docker.
```
docker build -t awsruby32 .
```
1. Desplácese hasta el directorio del proyecto que contiene el archivo `.rb` con el código del controlador de la función y el `Gemfile` para especificar las dependencias de la función. Desde dentro de ese directorio, ejecute el siguiente comando para iniciar el contenedor de Ruby Lambda.
------
#### [ Linux/MacOS ]
```
docker run --rm -it -v $PWD:/var/task -w /var/task awsruby32
```
**nota**
En macOS, es posible que vea una advertencia que informa que la plataforma de la imagen solicitada no coincide con la plataforma host detectada. Ignore esta advertencia.
------
#### [ Windows PowerShell ]
```
docker run --rm -it -v ${pwd}:var/task -w /var/task awsruby32
```
------
Cuando se inicie el contenedor, debería ver un mensaje de bash.
```
bash-4.2#
```
1. Configure la agrupación de paquetes para instalar las gemas especificadas en el `Gemfile` del directorio `vendor/bundle` local e instale las dependencias.
```
bash-4.2# bundle config set --local path 'vendor/bundle' && bundle install
```
1. Cree un paquete de despliegue con el código de la función y sus dependencias. En este ejemplo, el archivo que contiene el código del controlador de la función se llama `lambda_function.rb`.
```
bash-4.2# zip -r my_deployment_package.zip lambda_function.rb vendor
```
1. Salga del contenedor y regrese al directorio del proyecto local.
```
bash-4.2# exit
```
Ahora puede utilizar el paquete de despliegue del archivo .zip para crear o actualizar la función de Lambda. Consulte [Creación y actualización de funciones de Lambda Ruby mediante archivos .zip](#ruby-package-create-functions)
## Creación y actualización de funciones de Lambda Ruby mediante archivos .zip
Una vez que haya creado su paquete de implementación .zip, puede utilizarlo para crear una nueva función de Lambda o actualizar una existente. Puede implementar el paquete .zip a través de la consola, la AWS Command Line Interface y la API de Lambda. También puede crear y actualizar funciones de Lambda mediante AWS Serverless Application Model (AWS SAM) y CloudFormation.
El tamaño máximo de un paquete de despliegue .zip para Lambda es de 250 MB (descomprimido). Tenga en cuenta que este límite se aplica al tamaño combinado de todos los archivos que cargue, incluidas las capas de Lambda.
El tiempo de ejecución de Lambda necesita permiso para leer los archivos del paquete de implementación. En la notación octal de permisos de Linux, Lambda necesita 644 permisos para archivos no ejecutables (rw-r--r--) y 755 permisos (rwxr-xr-x) para directorios y archivos ejecutables.
En Linux y macOS, utilice el comando `chmod` para cambiar los permisos de los archivos y directorios del paquete de implementación. Por ejemplo, para conceder a un archivo no ejecutable los permisos correctos, ejecute el siguiente comando.
```
chmod 644
```
Para cambiar los permisos de los archivos en Windows, consulte [Set, View, Change, or Remove Permissions on an Object](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) en la documentación de Microsoft Windows.
**nota**
Si no concede a Lambda los permisos necesarios para acceder a los directorios del paquete de implementación, Lambda establecerá los permisos de esos directorios en 755 (rwxr-xr-x).
### Creación y actualización de funciones con archivos .zip mediante la consola
Para crear una nueva función, primero debe crearla en la consola y, a continuación, cargar el archivo .zip. Para actualizar una función existente, abra la página de la función correspondiente y, a continuación, siga el mismo procedimiento para agregar el archivo .zip actualizado.
Si el archivo .zip tiene un tamaño inferior a 50 MB, puede crear o actualizar una función al cargarlo directamente desde su equipo local. Para archivos .zip de más de 50 MB, primero debe cargar su paquete en un bucket de Amazon S3. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la Consola de administración de AWS, consulte [Introducción a Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). Para cargar archivos mediante la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI*.
**nota**
No puede cambiar el [tipo de paquete de implementación](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip o imagen de contenedor) de una función existente. Por ejemplo, no se puede convertir una función de imagen de contenedor para utilizar un archivo .zip. Debe crear una nueva función.
**Para crear una nueva función (consola)**
1. Abra la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y elija **Crear función**.
1. Elija **Crear desde cero**.
1. En **Información básica**, haga lo siguiente:
1. En **Nombre de la función**, escriba el nombre de la función.
1. En **Tiempo de ejecución**, seleccione el tiempo de ejecución que desea utilizar.
1. (Opcional) Para **Arquitectura**, elija la arquitectura del conjunto de instrucciones para su función. La arquitectura predeterminada es x86\$164. Asegúrese de que el paquete de despliegue .zip para su función sea compatible con la arquitectura del conjunto de instrucciones que seleccione.
1. (Opcional) En **Permisos**, expanda **Cambiar función de ejecución predeterminada**. Puede crear un nuevo **Rol de ejecución** o utilizar uno existente.
1. Seleccione **Creación de función**. Lambda crea una función básica “Hola, mundo” mediante el tiempo de ejecución elegido.
**Para cargar un archivo .zip desde su equipo local (consola)**
1. En la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda, elija la función para la que desea cargar el archivo .zip.
1. Seleccione la pestaña **Código**.
1. En el panel **Código fuente**, elija **Cargar desde**.
1. Elija un **archivo .zip**.
1. Para cargar el archivo .zip, haga lo siguiente:
1. Seleccione **Cargar** y, a continuación, seleccione su archivo .zip en el selector de archivos.
1. Elija **Abrir**.
1. Seleccione **Guardar**.
**Carga de un archivo .zip desde un bucket de Amazon S3 (consola)**
1. En la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda, elija la función para la que desea cargar un nuevo archivo .zip.
1. Seleccione la pestaña **Código**.
1. En el panel **Código fuente**, elija **Cargar desde**.
1. Elija la **ubicación de Amazon S3**.
1. Pegue la URL del enlace de Amazon S3 de su archivo .zip y seleccione **Guardar**.
### Actualización de las funciones del archivo .zip mediante el editor de código de la consola
Para algunas funciones con paquetes de despliegue en formato .zip, puede utilizar el editor de código integrado en la consola de Lambda para actualizar el código de la función de forma directa. Para utilizar esta característica, la función debe cumplir los siguientes criterios:
+ La función debe utilizar uno de los tiempos de ejecución del lenguaje interpretado (Python, Node.js o Ruby)
+ El paquete de implementación de la función debe tener un tamaño inferior a 50 MB (sin comprimir).
El código de función de las funciones con paquetes de despliegue de imágenes de contenedores no se puede editar directamente en la consola.
**Para actualizar el código de función mediante el editor de código de la consola**
1. Abra la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y seleccione su función.
1. Seleccione la pestaña **Código**.
1. En el panel **Código fuente**, seleccione su archivo de código fuente y edítelo en el editor de código integrado.
1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
### Creación y actualización de funciones con archivos .zip mediante la AWS CLI
Puede utilizar la [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) para crear una nueva función o actualizar una existente con un archivo .zip. Utilice los comandos [create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) y [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) para implementar su paquete .zip. Si el archivo .zip tiene un tamaño inferior a 50 MB, puede cargarlo desde una ubicación de archivo en su equipo de compilación local. Para archivos más grandes, debe cargar su paquete .zip desde un bucket de Amazon S3. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI*.
**nota**
Si carga su archivo .zip desde un bucket de Amazon S3 con la AWS CLI, el bucket debe estar ubicado en la misma Región de AWS que su función.
Para crear una nueva función mediante un archivo .zip con la AWS CLI, debe especificar lo siguiente:
+ El nombre de la función (`--function-name`).
+ El tiempo de ejecución de la función (`--runtime`).
+ El nombre de recurso de Amazon (ARN) del [rol de ejecución](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) de la función (`--role`).
+ El nombre del método de controlador en el código de la función (`--handler`).
También debe especificar la ubicación del archivo .zip. Si el archivo .zip se encuentra en una carpeta de su equipo de compilación local, utilice la opción `--zip-file` para especificar la ruta del archivo, como se muestra en el siguiente comando de ejemplo.
```
aws lambda create-function --function-name myFunction \
--runtime ruby3.2 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Para especificar la ubicación del archivo .zip en un bucket de Amazon S3, utilice la opción `--code`, como se muestra en el siguiente comando de ejemplo. Solo necesita utilizar el parámetro `S3ObjectVersion` para los objetos con versiones.
```
aws lambda create-function --function-name myFunction \
--runtime ruby3.2 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
Para actualizar una función existente mediante la CLI, especifique el nombre de la función mediante el parámetro `--function-name`. También debe especificar la ubicación del archivo .zip que desea utilizar para actualizar el código de la función. Si el archivo .zip se encuentra en una carpeta de su equipo de compilación local, utilice la opción `--zip-file` para especificar la ruta del archivo, como se muestra en el siguiente comando de ejemplo.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Para especificar la ubicación del archivo .zip en un bucket de Amazon S3, utilice las opciones `--s3-bucket` y `--s3-key` tal como se muestra en el siguiente comando de ejemplo. Solo necesita utilizar el parámetro `--s3-object-version` para los objetos con versiones.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Creación y actualización de funciones con archivos .zip mediante la API de Lambda
Para crear y actualizar funciones con un archivo de archivos .zip, utilice las siguientes operaciones de la API:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
### Creación y actualización de funciones con archivos .zip mediante AWS SAM
AWS Serverless Application Model (AWS SAM) es un conjunto de herramientas que ayuda a agilizar el proceso de creación y ejecución de aplicaciones sin servidor en AWS. Defina los recursos de su aplicación en una plantilla YAML o JSON y utilice la interfaz de la línea de comandos de AWS SAM (AWS SAM CLI) para crear, empaquetar e implementar sus aplicaciones. Al crear una función de Lambda a partir de una plantilla de AWS SAM, AWS SAM crea automáticamente un paquete de despliegue .zip o una imagen de contenedor con el código de la función y las dependencias que especifique. Para obtener más información sobre el uso de AWS SAM para crear e implementar funciones de Lambda, consulte [Introducción a AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) en la *Guía para desarrolladores de AWS Serverless Application Model*.
También puede utilizar AWS SAM para crear una función de Lambda con un archivo de archivos .zip existente. Para crear una función de Lambda mediante AWS SAM, puede guardar el archivo .zip en un bucket de Amazon S3 o en una carpeta local de su equipo de compilación. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI*.
En la plantilla de AWS SAM, el recurso `AWS::Serverless::Function` especifica la función de Lambda. En este recurso, establezca las siguientes propiedades para crear una función mediante un archivo de archivos .zip:
+ `PackageType`: se establece como `Zip`.
+ `CodeUri`: se establece como el URI de Amazon S3, la ruta a la carpeta local o el objeto [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html) del código de la función.
+ `Runtime`: se establece como el entorno de ejecución elegido
Con AWS SAM, si su archivo .zip tiene más de 50 MB, no es necesario cargarlo primero en un bucket de Amazon S3. AWS SAM puede cargar paquetes .zip hasta el tamaño máximo permitido de 250 MB (descomprimidos) desde una ubicación de su equipo de compilación local.
Para obtener más información sobre la implementación de funciones mediante un archivo .zip en AWS SAM, consulte [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) en la *Guía para desarrolladores de AWS SAM*.
### Creación y actualización de funciones con archivos .zip mediante CloudFormation
Puede utilizar CloudFormation para crear una función de Lambda con un archivo de archivos .zip. Para crear una función de Lambda a partir de un archivo .zip, primero debe cargar el archivo a un bucket de Amazon S3. Para obtener instrucciones sobre cómo cargar un archivo en un bucket de Amazon S3 con la AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) en la *Guía del usuario de la AWS CLI.*
En la plantilla de CloudFormation, el recurso `AWS::Lambda::Function` especifica la función de Lambda. En este recurso, establezca las siguientes propiedades para crear una función mediante un archivo de archivos .zip:
+ `PackageType`: se establece como `Zip`.
+ `Code`: ingrese el nombre del bucket de Amazon S3 y el nombre del archivo .zip en los campos `S3Bucket` y `S3Key`.
+ `Runtime`: se establece como el tiempo de ejecución elegido.
El archivo .zip que genera CloudFormation no puede superar los 4 MB. Para obtener más información sobre la implementación de funciones mediante un archivo .zip en CloudFormation, consulte [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html) en la *Guía del usuario de CloudFormation*.
# Implementación de funciones de Lambda de Ruby con imágenes de contenedor
Hay tres formas de crear una imagen de contenedor para una función de Lambda en Ruby:
+ [Uso de una imagen base de AWS para Ruby](#ruby-image-instructions)
Las [imágenes base de AWS](images-create.md#runtimes-images-lp) vienen precargadas con un tiempo de ejecución de lenguaje, un cliente de interfaz de tiempo de ejecución para administrar la interacción entre Lambda y el código de la función y un emulador de interfaz de tiempo de ejecución para realizar pruebas a nivel local.
+ [Uso de una imagen base exclusiva del sistema operativo de AWS](images-create.md#runtimes-images-provided)
[Las imágenes base exclusivas del sistema operativo de AWS](https://gallery.ecr.aws/lambda/provided)contienen una distribución de Amazon Linux y el [emulador de interfaz de tiempo de ejecución](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Por lo general, estas imágenes se utilizan para crear imágenes contenedoras para lenguajes compilados, como [Go](go-image.md#go-image-provided) y [Rust](lambda-rust.md), y para un lenguaje o versión de un lenguaje para los que Lambda no proporciona una imagen base, como Node.js 19. También puede usar imágenes base exclusivas del sistema operativo para implementar un [tiempo de ejecución personalizado](runtimes-custom.md). Para que la imagen sea compatible con Lambda, debe incluir el [cliente de interfaz de tiempo de ejecución para Ruby](#ruby-image-clients) en la imagen.
+ [Uso de una imagen base que no sea de AWS](#ruby-image-clients)
Puede utilizar una imagen base alternativa de otro registro de contenedores, como Alpine Linux o Debian. También puede utilizar una imagen personalizada creada por su organización. Para que la imagen sea compatible con Lambda, debe incluir el [cliente de interfaz de tiempo de ejecución para Ruby](#ruby-image-clients) en la imagen.
**sugerencia**
Para reducir el tiempo que tardan las funciones de contenedor de Lambda en activarse, consulte [Uso de compilaciones de varias fases](https://docs.docker.com/build/building/multi-stage/) en la documentación de Docker. Para compilar imágenes de contenedores eficientes, siga [Prácticas recomendadas para escribir Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
En esta página, se explica cómo compilar, probar e implementar imágenes de contenedor para Lambda.
**Topics**
+ [
## AWSImágenes base de para Ruby
](#ruby-image-base)
+ [
## Uso de una imagen base de AWS para Ruby
](#ruby-image-instructions)
+ [
## Uso de una imagen base alternativa con el cliente de interfaz de tiempo de ejecución
](#ruby-image-clients)
## AWSImágenes base de para Ruby
AWS proporciona las siguientes imágenes base para Ruby:
| Etiquetas | Tiempo de ejecución | Sistema operativo | Dockerfile | Obsolescencia |
| --- | --- | --- | --- | --- |
| 3.4 | Ruby 3.4 | Amazon Linux 2023 | [Dockerfile para Ruby 3.4 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.4/Dockerfile.ruby3.4) | 31 de marzo de 2028 |
| 3.3 | Ruby 3.3 | Amazon Linux 2023 | [Dockerfile para Ruby 3.3 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.3/Dockerfile.ruby3.3) | 31 de marzo de 2027 |
| 3.2 | Ruby 3.2 | Amazon Linux 2 | [Dockerfile para Ruby 3.2 en GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.2/Dockerfile.ruby3.2) | 31 de marzo de 2026 |
Repositorio de Amazon ECR: [gallery.ecr.aws/lambda/ruby](https://gallery.ecr.aws/lambda/ruby)
## Uso de una imagen base de AWS para Ruby
### Requisitos previos
Para completar los pasos de esta sección, debe disponer de lo siguiente:
+ [AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versión mínima 25.0.0)
+ El [complemento buildx](https://github.com/docker/buildx/blob/master/README.md) de Docker.
+ Ruby
### Creación de una imagen a partir de una imagen base
**Cómo crear una imagen de contenedor para Ruby**
1. Cree un directorio para el proyecto y, a continuación, cambie a ese directorio.
```
mkdir example
cd example
```
1. Cree un nuevo archivo denominado `Gemfile`. Aquí se enumeran los paquetes de RubyGems necesarios para la aplicación. AWS SDK para Ruby está disponible en RubyGems. Debe elegir archivos gem de servicios de AWS específicos para instalar. Por ejemplo, para utilizar la [gema de Ruby para Lambda](https://rubygems.org/gems/aws-sdk-lambda/), su Gemfile debe tener este aspecto:
```
source 'https://rubygems.org'
gem 'aws-sdk-lambda'
```
Como alternativa, el archivo gem [aws-sdk](https://rubygems.org/gems/aws-sdk/) contiene todos los archivos gem de los servicios de AWS disponibles. Este archivo gem es muy grande. Le recomendamos que lo utilice solo si depende de muchos servicios de AWS.
1. Instale las dependencias especificadas en el Gemfile mediante el [paquete de instalación](https://bundler.io/v2.4/man/bundle-install.1.html).
```
bundle install
```
1. Cree un nuevo archivo denominado `lambda_function.rb`. Puede agregar el siguiente código de función de muestra al archivo para realizar pruebas o utilizar su propio código.
**Example Función de Ruby**
```
module LambdaFunction
class Handler
def self.process(event:,context:)
"Hello from Lambda!"
end
end
end
```
1. Cree un nuevo Dockerfile. El siguiente Dockerfile de ejemplo utiliza una [imagen base de AWS](images-create.md#runtimes-images-lp). Este Dockerfile utiliza la siguiente configuración:
+ Establezca la propiedad `FROM` en el URI de la imagen base.
+ Utilice el comando COPY para copiar el código de la función y las dependencias del tiempo de ejecución a `{LAMBDA_TASK_ROOT}`, una [variable de entorno definido de Lambda](configuration-envvars.md#configuration-envvars-runtime).
+ Establezca el argumento `CMD` para el controlador de la función de Lambda.
Tenga en cuenta que el Dockerfile de ejemplo no incluye una [instrucción USER](https://docs.docker.com/reference/dockerfile/#user). Al implementar una imagen de contenedor en Lambda, Lambda define automáticamente un usuario predeterminado de Linux con permisos de privilegio mínimo. Esto es diferente del comportamiento estándar de Docker, que utiliza de forma predeterminada el usuario `root` cuando no se proporciona ninguna instrucción `USER`.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/ruby:3.4
# Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ${LAMBDA_TASK_ROOT}/
# Install Bundler and the specified gems
RUN gem install bundler:2.4.20 && \
bundle config set --local path 'vendor/bundle' && \
bundle install
# Copy function code
COPY lambda_function.rb ${LAMBDA_TASK_ROOT}/
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.LambdaFunction::Handler.process" ]
```
1. Cree la imagen de Docker con el comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). En el siguiente ejemplo se asigna un nombre a la imagen `docker-image` y se le asigna la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Para que la imagen sea compatible con Lambda, debe usar la opción `--provenance=false`.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**nota**
El comando especifica la opción `--platform linux/amd64` para garantizar que el contenedor sea compatible con el entorno de ejecución de Lambda, independientemente de la arquitectura de la máquina de compilación. Si tiene intención de crear una función de Lambda con la arquitectura del conjunto de instrucciones ARM64, asegúrese de cambiar el comando para utilizar la opción `--platform linux/arm64` en su lugar.
### (Opcional) Prueba de la imagen de forma local
1. Inicie la imagen de Docker con el comando **docker run**. En este ejemplo, `docker-image` es el nombre de la imagen y `test` es la etiqueta.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
Este comando ejecuta la imagen como un contenedor y crea un punto de conexión local en `localhost:9000/2015-03-31/functions/function/invocations`.
**nota**
Si creó la imagen de Docker para la arquitectura del conjunto de instrucciones ARM64, asegúrese de utilizar la opción `--platform linux/arm64` en lugar de `--platform linux/amd64`.
1. Desde una nueva ventana de terminal, publique un evento en el punto de conexión local.
------
#### [ Linux/macOS ]
En Linux y macOS, ejecute el siguiente comando `curl`:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Si utiliza su propio código de función en lugar del código de función de ejemplo, quizás quiera invocar la función con una carga JSON. Ejemplo:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
En PowerShell, ejecute el siguiente comando `Invoke-WebRequest`:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Si utiliza su propio código de función en lugar del código de función de ejemplo, quizás quiera invocar la función con una carga JSON. Ejemplo:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Obtenga el ID del contenedor.
```
docker ps
```
1. Use el comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) para detener el contenedor. En este comando, reemplace `3766c4ab331c` por el ID del contenedor del paso anterior.
```
docker kill 3766c4ab331c
```
### Implementación de la imagen
**Para cargar la imagen en Amazon ECR y crear la función de Lambda**
1. Para autenticar la CLI de Docker en su registro de Amazon ECR, ejecute el comando [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html).
+ Establezca el valor de `--region` en la Región de AWS en la que desee crear el repositorio de Amazon ECR.
+ Reemplace `111122223333` por el ID de su Cuenta de AWS.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Cree un repositorio en Amazon ECR con el comando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**nota**
El repositorio de Amazon ECR debe estar en la misma Región de AWS que la función de Lambda.
Si se realiza de la forma correcta, verá una respuesta como la siguiente:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Copie el valor de `repositoryUri` de la salida del paso anterior.
1. Ejecute el comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) para etiquetar la imagen local en su repositorio de Amazon ECR como la versión más reciente. En este comando:
+ `docker-image:test` es el nombre y la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) de su imagen de Docker. Son el nombre y la etiqueta de la imagen que especificó en el comando `docker build`.
+ Reemplace `` por el `repositoryUri` que ha copiado. Asegúrese de incluir `:latest` al final del URI.
```
docker tag docker-image:test :latest
```
Ejemplo:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Ejecute el comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) para implementar la imagen local en el repositorio de Amazon ECR. Asegúrese de incluir `:latest` al final del URI del repositorio.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Cree un rol de ejecución](lambda-intro-execution-role.md#permissions-executionrole-api) para la función si aún no tiene uno. Necesitará el nombre de recurso de Amazon (ARN) del rol en el paso siguiente.
1. Cree la función de Lambda. En `ImageUri`, especifique el URI del repositorio anterior. Asegúrese de incluir `:latest` al final del URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**nota**
Puede crear una función con una imagen de una cuenta AWS diferente, siempre que la imagen esté en la misma región que la función de Lambda. Para obtener más información, consulte [Permisos entre cuentas de Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Invoque la función.
```
aws lambda invoke --function-name hello-world response.json
```
Debería ver una respuesta como la siguiente:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Para ver la salida de la función, compruebe el archivo `response.json`.
Para actualizar el código de la función, debe volver a compilar la imagen, cargar la nueva imagen en el repositorio de Amazon ECR y, a continuación, utilizar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) para implementar la imagen en la función de Lambda.
Lambda resuelve la etiqueta de la imagen en un resumen de imagen específico. Esto significa que si apunta la etiqueta de imagen que se utilizó para implementar la función a una nueva imagen en Amazon ECR, Lambda no actualiza automáticamente la función para usar la nueva imagen.
Para implementar la nueva imagen en la misma función de Lambda, debe usar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), incluso si la etiqueta de la imagen en Amazon ECR sigue siendo la misma. En el siguiente ejemplo, la opción `--publish` crea una nueva versión de la función con la imagen del contenedor actualizada.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Uso de una imagen base alternativa con el cliente de interfaz de tiempo de ejecución
Si usa una [imagen base exclusiva del sistema operativo](images-create.md#runtimes-images-provided) o una imagen base alternativa, debe incluir el cliente de interfaz de tiempo de ejecución en su imagen. El cliente de interfaz de tiempo de ejecución extiende el [API de tiempo de ejecución](runtimes-api.md), que administra la interacción entre Lambda y el código de la función.
Instale el [cliente de interfaz de tiempo de ejecución de Lambda para Ruby](https://rubygems.org/gems/aws_lambda_ric) mediante el administrador de paquetes de RubyGems.org:
```
gem install aws_lambda_ric
```
También puede descargar el [cliente de interfaz de tiempo de ejecución de Ruby](https://github.com/aws/aws-lambda-ruby-runtime-interface-client) desde GitHub.
En el siguiente ejemplo, se muestra cómo crear una imagen de contenedor para Ruby con una imagen base que no es de AWS. El Dockerfile de ejemplo utiliza una imagen base oficial de Ruby. El Dockerfile incluye el cliente de interfaz de tiempo de ejecución.
### Requisitos previos
Para completar los pasos de esta sección, debe disponer de lo siguiente:
+ [AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versión mínima 25.0.0)
+ El [complemento buildx](https://github.com/docker/buildx/blob/master/README.md) de Docker.
+ Ruby
### Creación de imágenes a partir de una imagen base alternativa
**Para crear una imagen de contenedor para Ruby a partir de una imagen base alternativa**
1. Cree un directorio para el proyecto y, a continuación, cambie a ese directorio.
```
mkdir example
cd example
```
1. Cree un nuevo archivo denominado `Gemfile`. Aquí se enumeran los paquetes de RubyGems necesarios para la aplicación. AWS SDK para Ruby está disponible en RubyGems. Debe elegir archivos gem de servicios de AWS específicos para instalar. Por ejemplo, para utilizar la [gema de Ruby para Lambda](https://rubygems.org/gems/aws-sdk-lambda/), su Gemfile debe tener este aspecto:
```
source 'https://rubygems.org'
gem 'aws-sdk-lambda'
```
Como alternativa, el archivo gem [aws-sdk](https://rubygems.org/gems/aws-sdk/) contiene todos los archivos gem de los servicios de AWS disponibles. Este archivo gem es muy grande. Le recomendamos que lo utilice solo si depende de muchos servicios de AWS.
1. Instale las dependencias especificadas en el Gemfile mediante el [paquete de instalación](https://bundler.io/v2.4/man/bundle-install.1.html).
```
bundle install
```
1. Cree un nuevo archivo denominado `lambda_function.rb`. Puede agregar el siguiente código de función de muestra al archivo para realizar pruebas o utilizar su propio código.
**Example Función de Ruby**
```
module LambdaFunction
class Handler
def self.process(event:,context:)
"Hello from Lambda!"
end
end
end
```
1. Cree un nuevo Dockerfile. El siguiente Dockerfile utiliza una imagen base de Ruby en lugar de una [imagen base de AWS](images-create.md#runtimes-images-lp). El Dockerfile incluye el [cliente de interfaz de tiempo de ejecución para Ruby](https://github.com/aws/aws-lambda-ruby-runtime-interface-client), que hace que la imagen sea compatible con Lambda. Como alternativa, puede agregar el cliente de interfaz de tiempo de ejecución al Gemfile de su aplicación.
+ Establezca la propiedad `FROM` como la imagen base de Ruby.
+ Cree un directorio para el código de la función y una variable de entorno que apunte a ese directorio. En este ejemplo, el directorio es `/var/task`, que replica el entorno de ejecución de Lambda. Sin embargo, puede elegir cualquier directorio para el código de la función porque el Dockerfile no utiliza una imagen base AWS.
+ Configure `ENTRYPOINT` como el módulo que desea que el contenedor de Docker ejecute cuando se inicie. En este caso, el módulo es el cliente de interfaz de tiempo de ejecución.
+ Establezca el argumento `CMD` para el controlador de la función de Lambda.
Tenga en cuenta que el Dockerfile de ejemplo no incluye una [instrucción USER](https://docs.docker.com/reference/dockerfile/#user). Al implementar una imagen de contenedor en Lambda, Lambda define automáticamente un usuario predeterminado de Linux con permisos de privilegio mínimo. Esto es diferente del comportamiento estándar de Docker, que utiliza de forma predeterminada el usuario `root` cuando no se proporciona ninguna instrucción `USER`.
**Example Dockerfile**
```
FROM ruby:2.7
# Install the runtime interface client for Ruby
RUN gem install aws_lambda_ric
# Add the runtime interface client to the PATH
ENV PATH="/usr/local/bundle/bin:${PATH}"
# Create a directory for the Lambda function
ENV LAMBDA_TASK_ROOT=/var/task
RUN mkdir -p ${LAMBDA_TASK_ROOT}
WORKDIR ${LAMBDA_TASK_ROOT}
# Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ${LAMBDA_TASK_ROOT}/
# Install Bundler and the specified gems
RUN gem install bundler:2.4.20 && \
bundle config set --local path 'vendor/bundle' && \
bundle install
# Copy function code
COPY lambda_function.rb ${LAMBDA_TASK_ROOT}/
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "aws_lambda_ric" ]
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.LambdaFunction::Handler.process" ]
```
1. Cree la imagen de Docker con el comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). En el siguiente ejemplo se asigna un nombre a la imagen `docker-image` y se le asigna la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Para que la imagen sea compatible con Lambda, debe usar la opción `--provenance=false`.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**nota**
El comando especifica la opción `--platform linux/amd64` para garantizar que el contenedor sea compatible con el entorno de ejecución de Lambda, independientemente de la arquitectura de la máquina de compilación. Si tiene intención de crear una función de Lambda con la arquitectura del conjunto de instrucciones ARM64, asegúrese de cambiar el comando para utilizar la opción `--platform linux/arm64` en su lugar.
### (Opcional) Prueba de la imagen de forma local
Utilice el [emulador de interfaz de tiempo de ejecución](https://github.com/aws/aws-lambda-runtime-interface-emulator/) para probar la imagen localmente. Puede [crear el emulador en su imagen](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) o usar el procedimiento siguiente para instalarlo en su equipo local.
**Para instalar y ejecutar el emulador de interfaz de tiempo de ejecución en su equipo local**
1. Desde el directorio del proyecto, ejecute el siguiente comando para descargar el emulador de interfaz de tiempo de ejecución (arquitectura x86-64) de GitHub e instalarlo en su equipo local.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Para instalar el emulador arm64, reemplace la URL del repositorio de GitHub en el comando anterior por lo siguiente:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Para instalar el emulador arm64, reemplace el `$downloadLink` con lo siguiente:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Inicie la imagen de Docker con el comando **docker run**. Tenga en cuenta lo siguiente:
+ `docker-image` es el nombre de la imagen y `test` es la etiqueta.
+ `aws_lambda_ric lambda_function.LambdaFunction::Handler.process` es el `ENTRYPOINT` seguido del `CMD` de su Dockerfile.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
aws_lambda_ric lambda_function.LambdaFunction::Handler.process
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
aws_lambda_ric lambda_function.LambdaFunction::Handler.process
```
------
Este comando ejecuta la imagen como un contenedor y crea un punto de conexión local en `localhost:9000/2015-03-31/functions/function/invocations`.
**nota**
Si creó la imagen de Docker para la arquitectura del conjunto de instrucciones ARM64, asegúrese de utilizar la opción `--platform linux/arm64` en lugar de `--platform linux/amd64`.
1. Publique un evento en el punto de conexión local.
------
#### [ Linux/macOS ]
En Linux y macOS, ejecute el siguiente comando `curl`:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Si utiliza su propio código de función en lugar del código de función de ejemplo, quizás quiera invocar la función con una carga JSON. Ejemplo:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
En PowerShell, ejecute el siguiente comando `Invoke-WebRequest`:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Este comando invoca la función con un evento vacío y devuelve una respuesta. Si utiliza su propio código de función en lugar del código de función de ejemplo, quizás quiera invocar la función con una carga JSON. Ejemplo:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Obtenga el ID del contenedor.
```
docker ps
```
1. Use el comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) para detener el contenedor. En este comando, reemplace `3766c4ab331c` por el ID del contenedor del paso anterior.
```
docker kill 3766c4ab331c
```
### Implementación de la imagen
**Para cargar la imagen en Amazon ECR y crear la función de Lambda**
1. Para autenticar la CLI de Docker en su registro de Amazon ECR, ejecute el comando [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html).
+ Establezca el valor de `--region` en la Región de AWS en la que desee crear el repositorio de Amazon ECR.
+ Reemplace `111122223333` por el ID de su Cuenta de AWS.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Cree un repositorio en Amazon ECR con el comando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**nota**
El repositorio de Amazon ECR debe estar en la misma Región de AWS que la función de Lambda.
Si se realiza de la forma correcta, verá una respuesta como la siguiente:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Copie el valor de `repositoryUri` de la salida del paso anterior.
1. Ejecute el comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) para etiquetar la imagen local en su repositorio de Amazon ECR como la versión más reciente. En este comando:
+ `docker-image:test` es el nombre y la [etiqueta](https://docs.docker.com/engine/reference/commandline/build/#tag) de su imagen de Docker. Son el nombre y la etiqueta de la imagen que especificó en el comando `docker build`.
+ Reemplace `` por el `repositoryUri` que ha copiado. Asegúrese de incluir `:latest` al final del URI.
```
docker tag docker-image:test :latest
```
Ejemplo:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Ejecute el comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) para implementar la imagen local en el repositorio de Amazon ECR. Asegúrese de incluir `:latest` al final del URI del repositorio.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Cree un rol de ejecución](lambda-intro-execution-role.md#permissions-executionrole-api) para la función si aún no tiene uno. Necesitará el nombre de recurso de Amazon (ARN) del rol en el paso siguiente.
1. Cree la función de Lambda. En `ImageUri`, especifique el URI del repositorio anterior. Asegúrese de incluir `:latest` al final del URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**nota**
Puede crear una función con una imagen de una cuenta AWS diferente, siempre que la imagen esté en la misma región que la función de Lambda. Para obtener más información, consulte [Permisos entre cuentas de Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Invoque la función.
```
aws lambda invoke --function-name hello-world response.json
```
Debería ver una respuesta como la siguiente:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Para ver la salida de la función, compruebe el archivo `response.json`.
Para actualizar el código de la función, debe volver a compilar la imagen, cargar la nueva imagen en el repositorio de Amazon ECR y, a continuación, utilizar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) para implementar la imagen en la función de Lambda.
Lambda resuelve la etiqueta de la imagen en un resumen de imagen específico. Esto significa que si apunta la etiqueta de imagen que se utilizó para implementar la función a una nueva imagen en Amazon ECR, Lambda no actualiza automáticamente la función para usar la nueva imagen.
Para implementar la nueva imagen en la misma función de Lambda, debe usar el comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), incluso si la etiqueta de la imagen en Amazon ECR sigue siendo la misma. En el siguiente ejemplo, la opción `--publish` crea una nueva versión de la función con la imagen del contenedor actualizada.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# Uso de capas para funciones de Lambda en Ruby
Utilice [capas de Lambda](chapter-layers.md) para empaquetar el código y las dependencias que desee reutilizar en varias funciones. Las capas suelen contener dependencias de biblioteca, un [tiempo de ejecución personalizado](runtimes-custom.md) o archivos de configuración. La creación de una capa implica tres pasos generales:
1. Empaquete el contenido de su capa. Esto significa crear un archivo de archivo. zip que contenga las dependencias que desea usar en sus funciones.
1. Cree la capa en Lambda.
1. Agregue la capa a sus funciones.
**Topics**
+ [
## Empaquete el contenido de su capa.
](#ruby-layers-package)
+ [
## Creación de la capa en Lambda
](#publishing-layer)
+ [
## Utilización de gemas de capas en una función
](#ruby-layers-bundler-limitations)
+ [
## Adición de la capa a la función
](#ruby-layer-adding)
+ [
## Aplicación de ejemplo
](#ruby-layer-sample-app)
## Empaquete el contenido de su capa.
Para crear una capa, agrupe sus paquetes en un archivo .zip que cumpla con los siguientes requisitos:
+ Cree la capa con la misma versión de Ruby que tiene previsto usar para la función de Lambda. Por ejemplo, si crea una capa para Ruby 3.4, utilice el tiempo de ejecución de Ruby 3.4 para su función.
+ El archivo .zip de su capa debe usar una de estas estructuras de directorios:
+ `ruby/gems/x.x.x` (donde *x.x.x* es su versión de Ruby, por ejemplo `3.4.0`)
+ `ruby/lib`
Para obtener más información, consulte [Rutas de capa para cada tiempo de ejecución de Lambda](packaging-layers.md#packaging-layers-paths).
+ Los paquetes de la capa deben ser compatibles con Linux. Las funciones de Lambda se ejecutan en Amazon Linux.
Puede crear capas que contengan gemas de Ruby de terceros o sus propios módulos y clases de Ruby. Muchas gemas populares de Ruby contienen extensiones nativas (código C) que deben compilarse para el entorno de Lambda de Linux.
### Ruby con gemas puras
Las gemas puras de Ruby contienen solo código de Ruby y no requieren compilación. Estas gemas son más fáciles de empaquetar y funcionan en diferentes plataformas.
**Creación de una capa usando gemas puras de Ruby**
1. Cree un `Gemfile` para especificar las gemas puras de Ruby que desea incluir en su capa:
**Example Archivo Gemfile**
```
source 'https://rubygems.org'
gem 'tzinfo'
```
1. Instale las gemas en el directorio `vendor/bundle` mediante Bundler:
```
bundle config set --local path vendor/bundle
bundle install
```
1. Copie las gemas instaladas a la estructura de directorios que Lambda requiere `ruby/gems/3.4.0`):
```
mkdir -p ruby/gems/3.4.0
cp -r vendor/bundle/ruby/3.4.0*/* ruby/gems/3.4.0/
```
1. Comprima en formato zip el contenido de la capa:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
La estructura de directorios del archivo .zip debería ser similar a la siguiente:
```
ruby/
└── gems/
└── 3.4.0/
├── gems/
│ ├── concurrent-ruby-1.3.5/
│ └── tzinfo-2.0.6/
├── specifications/
├── cache/
├── build_info/
└── (other bundler directories)
```
**nota**
Debe incluir cada gema de forma individual en el código de la función. No puede utilizar `bundler/setup` o `Bundler.require`. Para obtener más información, consulte [Utilización de gemas de capas en una función](#ruby-layers-bundler-limitations).
### Gemas con extensiones nativas
Muchas gemas de Ruby populares contienen extensiones nativas (código C) que deben compilarse para la plataforma de destino. Entre las gemas más populares con extensiones nativas se encuentran [nokogiri](https://rubygems.org/gems/nokogiri/), [pg](https://rubygems.org/gems/pg/), [mysql2](https://rubygems.org/gems/mysql2/), [sqlite3](https://rubygems.org/gems/sqlite3/) y [ffi](https://rubygems.org/gems/ffi/). Estas gemas se deben crear en un entorno de Linux que sea compatible con el tiempo de ejecución de Lambda.
**Creación de una capa con gemas con extensiones nativas**
1. Creación de una `Gemfile`.
**Example Archivo Gemfile**
```
source 'https://rubygems.org'
gem 'nokogiri'
gem 'httparty'
```
1. Utilice Docker para crear las gemas en un entorno de Linux que sea compatible con Lambda. Especifique una [imagen base de AWS](ruby-image.md#ruby-image-base) en su Dockerfile:
**Example Dockerfile para Ruby 3.4**
```
FROM public.ecr.aws/lambda/ruby:3.4
# Copy Gemfile
COPY Gemfile ./
# Install system dependencies for native extensions
RUN dnf update -y && \
dnf install -y gcc gcc-c++ make
# Configure bundler and install gems
RUN bundle config set --local path vendor/bundle && \
bundle install
# Create the layer structure
RUN mkdir -p ruby/gems/3.4.0 && \
cp -r vendor/bundle/ruby/3.4.0*/* ruby/gems/3.4.0/
# Create the layer zip file
RUN zip -r layer.zip ruby/
```
1. Cree la imagen y extraiga la capa:
```
docker build -t ruby-layer-builder .
docker run --rm -v $(pwd):/output --entrypoint cp ruby-layer-builder layer.zip /output/
```
Esto crea las gemas en el entorno de Linux correcto y copia el archivo `layer.zip` a su directorio local. La estructura de directorios del archivo .zip debería ser similar a la siguiente:
```
ruby/
└── gems/
└── 3.4.0/
├── gems/
│ ├── bigdecimal-3.2.2/
│ ├── csv-3.3.5/
│ ├── httparty-0.23.1/
│ ├── mini_mime-1.1.5/
│ ├── multi_xml-0.7.2/
│ ├── nokogiri-1.18.8-x86_64-linux-gnu/
│ └── racc-1.8.1/
├── build_info/
├── cache/
├── specifications/
└── (other bundler directories)
```
**nota**
Debe incluir cada gema de forma individual en el código de la función. No puede utilizar `bundler/setup` o `Bundler.require`. Para obtener más información, consulte [Utilización de gemas de capas en una función](#ruby-layers-bundler-limitations).
### Módulos de Ruby personalizados
**Creación de una capa con su propio código**
1. Cree la estructura del directorio necesario para su capa:
```
mkdir -p ruby/lib
```
1. Cree sus módulos de Ruby en el directorio `ruby/lib`. El siguiente módulo de ejemplo valida los pedidos mediante la confirmación de que contienen la información requerida.
**Example ruby/lib/order\$1validator.rb**
```
require 'json'
module OrderValidator
class ValidationError < StandardError; end
def self.validate_order(order_data)
# Validates an order and returns formatted data
required_fields = %w[product_id quantity]
# Check required fields
missing_fields = required_fields.reject { |field| order_data.key?(field) }
unless missing_fields.empty?
raise ValidationError, "Missing required fields: #{missing_fields.join(', ')}"
end
# Validate quantity
quantity = order_data['quantity']
unless quantity.is_a?(Integer) && quantity > 0
raise ValidationError, 'Quantity must be a positive integer'
end
# Format and return the validated data
{
'product_id' => order_data['product_id'].to_s,
'quantity' => quantity,
'shipping_priority' => order_data.fetch('priority', 'standard')
}
end
def self.format_response(status_code, body)
# Formats the API response
{
statusCode: status_code,
body: JSON.generate(body)
}
end
end
```
1. Comprima en formato zip el contenido de la capa:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
La estructura de directorios del archivo .zip debería ser similar a la siguiente:
```
ruby/
└── lib/
└── order_validator.rb
```
1. En su función, solicite y utilice los módulos. Debe incluir cada gema de forma individual en el código de la función. No puede utilizar `bundler/setup` o `Bundler.require`. Para obtener más información, consulte [Utilización de gemas de capas en una función](#ruby-layers-bundler-limitations). Ejemplo:
```
require 'json'
require 'order_validator'
def lambda_handler(event:, context:)
begin
# Parse the order data from the event body
order_data = JSON.parse(event['body'] || '{}')
# Validate and format the order
validated_order = OrderValidator.validate_order(order_data)
OrderValidator.format_response(200, {
message: 'Order validated successfully',
order: validated_order
})
rescue OrderValidator::ValidationError => e
OrderValidator.format_response(400, {
error: e.message
})
rescue => e
OrderValidator.format_response(500, {
error: 'Internal server error'
})
end
end
```
Puede usar el siguiente [evento de prueba](testing-functions.md#invoke-with-event) para invocar la función:
```
{
"body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}
```
Respuesta esperada:
```
{
"statusCode": 200,
"body": "{\"message\":\"Order validated successfully\",\"order\":{\"product_id\":\"ABC123\",\"quantity\":2,\"shipping_priority\":\"express\"}}"
}
```
## Creación de la capa en Lambda
También puede publicar la capa con la AWS CLI o la consola de Lambda.
------
#### [ AWS CLI ]
Ejecute el comando [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) de la AWS CLI para crear la capa de Lambda:
```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes ruby3.4
```
El parámetro [Tiempos de ejecución compatibles](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) es opcional. Cuando se especifica, Lambda usa este parámetro para filtrar las capas en la consola de Lambda.
------
#### [ Console ]
**Para crear una capa (consola)**
1. Abra la página de [Capas](https://console.aws.amazon.com/lambda/home#/layers) de la consola de Lambda.
1. Elija **Crear capa**.
1. Elija **Cargar un archivo .zip** y, a continuación, cargue el archivo .zip que creó anteriormente.
1. (Opcional) En **Tiempos de ejecución compatibles**, elija el tiempo de ejecución de Ruby que corresponda a la versión de Ruby que utilizó para crear la capa.
1. Seleccione **Crear**.
------
## Utilización de gemas de capas en una función
En el código de la función, debe especificar de forma explícita cada gema que desee utilizar. Los comandos de Bundler como `bundler/setup` y `Bundler.require` no son compatibles. A continuación, se explica cómo utilizar las gemas de una capa en una función de Lambda correctamente:
```
# Correct: Use explicit requires for each gem
require 'nokogiri'
require 'httparty'
def lambda_handler(event:, context:)
# Use the gems directly
doc = Nokogiri::HTML(event['html'])
response = HTTParty.get(event['url'])
# ... rest of your function
end
# Incorrect: These Bundler commands will not work
# require 'bundler/setup'
# Bundler.require
```
## Adición de la capa a la función
------
#### [ AWS CLI ]
Para adjuntar la capa a la función, ejecute el comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) de la AWS CLI. Para el parámetro `--layers`, use el ARN de la capa. El ARN debe especificar la versión (por ejemplo, `arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`). Para obtener más información, consulte [Capas y versiones de capas](chapter-layers.md#lambda-layer-versions).
```
aws lambda update-function-configuration --function-name my-function --cli-binary-format raw-in-base64-out --layers "arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1"
```
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*.
------
#### [ Console ]
**Adición de una capa a 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 la función.
1. Desplácese hacia abajo hasta la sección **Capas** y, a continuación, elija **Agregar una capa**.
1. En **Elija una capa**, seleccione **Capas personalizadas** y, a continuación, elija su capa.
**nota**
Si no agregó un [tiempo de ejecución compatible](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) al crear la capa, su capa no aparecerá aquí. Puede especificar el ARN de la capa en su lugar.
1. Elija **Agregar**.
------
## Aplicación de ejemplo
Para ver más ejemplos de cómo usar las capas de Lambda, consulte la aplicación de ejemplo [layer-ruby](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-ruby) en el repositorio de GitHub de la Guía para desarrolladores de AWS Lambda. Esta aplicación incluye una capa que contiene la biblioteca [tzinfo](https://rubygems.org/gems/tzinfo). Después de crear la capa, puede implementar e invocar las funciones correspondientes para confirmar que la capa funciona como se espera.
# Uso del objeto de contexto Lambda para recuperar la información de la función de Ruby
Cuando Lambda ejecuta su función, pasa un objeto context al [controlador](ruby-handler.md). Este objeto proporciona métodos y propiedades que facilitan información acerca de la invocación, la función y el entorno de ejecución.
**Métodos de context**
+ `get_remaining_time_in_millis`: devuelve el número de milisegundos que quedan antes del tiempo de espera de la ejecución.
**Propiedades de context**
+ `function_name`: el nombre de la función de Lambda.
+ `function_version`: la [versión](configuration-versions.md) de la función.
+ `invoked_function_arn`: el nombre de recurso de Amazon (ARN) que se utiliza para invocar esta función. Indica si el invocador especificó un número de versión o alias.
+ `memory_limit_in_mb`: cantidad de memoria asignada a la función.
+ `aws_request_id`: el identificador de la solicitud de invocación.
+ `log_group_name`: grupo de registros de para la función.
+ `log_stream_name`: el flujo de registro de la instancia de la función.
+ `deadline_ms`: la fecha en la que la función agota su tiempo de ejecución en milisegundos de tiempo Unix.
+ `identity`: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que autorizó la solicitud.
+ `client_context`: (aplicaciones móviles) Contexto de cliente proporcionado a Lambda por la aplicación cliente.
# Registro y supervisión de las funciones de Lambda
AWS Lambda supervisa automáticamente funciones de Lambda en su nombre y envía registros a Amazon CloudWatch. Su función de Lambda viene con un grupo de registros de Registros de CloudWatch y con un flujo de registro para cada instancia de su función. El entorno de tiempo de ejecución de Lambda envía detalles sobre cada invocación al flujo de registro y retransmite los registros y otras salidas desde el código de la función. Para obtener más información, consulte [Envío de registros de funciones de Lambda a Registros de CloudWatch](monitoring-cloudwatchlogs.md).
Esta página describe cómo producir resultados de registro a partir del código de la función de Lambda o registros de acceso mediante AWS Command Line Interface, la consola de Lambda o la consola de CloudWatch.
**Topics**
+ [
## Crear una función que devuelve registros
](#ruby-logging-output)
+ [
## Visualización de los registros en la consola de Lambda
](#ruby-logging-console)
+ [
## Visualización de los registros de en la consola de CloudWatch
](#ruby-logging-cwconsole)
+ [
## Visualización de los registros mediante la AWS Command Line Interface (AWS CLI)
](#ruby-logging-cli)
+ [
## Eliminación de registros
](#ruby-logging-delete)
+ [
## Trabajo con la biblioteca logger en Ruby
](#ruby-logging-lib)
## Crear una función que devuelve registros
Para generar registros desde el código de su función puede utilizar instrucciones `puts` o cualquier biblioteca de registro que escriba en `stdout` o en `stderr`. En el siguiente ejemplo, se registran los valores de las variables de entorno y el objeto de evento.
**Example lambda\$1function.rb**
```
# lambda_function.rb
def handler(event:, context:)
puts "## ENVIRONMENT VARIABLES"
puts ENV.to_a
puts "## EVENT"
puts event.to_a
end
```
**Example formato de registro**
```
START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled: true
```
El tiempo de ejecución de Ruby registra las líneas `START`, `END` y `REPORT` de cada invocación. La línea del informe proporciona los siguientes detalles.
**Campos de datos de línea REPORT**
+ **RequestId**: el ID de solicitud único para la invocación.
+ **Duración**: la cantidad de tiempo que el método de controlador de función pasó procesando el evento.
+ **Duración facturada**: la cantidad de tiempo facturado por la invocación.
+ **Tamaño de memoria**: la cantidad de memoria asignada a la función.
+ **Máximo de memoria usada**: la cantidad de memoria utilizada por la función. Cuando las invocaciones comparten un entorno de ejecución, Lambda informa de la memoria máxima utilizada en todas las invocaciones. Este comportamiento puede dar como resultado un valor notificado superior al esperado.
+ **Duración de inicio**: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en cargar la función y ejecutar código fuera del método del controlador.
+ **TraceId de XRAY**: para las solicitudes rastreadas, el [ID de seguimientode AWS X-Ray](services-xray.md).
+ **SegmentId**: para solicitudes rastreadas, el ID del segmento de X-Ray.
+ **Muestras**: para solicitudes rastreadas, el resultado del muestreo.
Para obtener registros más detallados, utilice [Trabajo con la biblioteca logger en Ruby](#ruby-logging-lib).
## Visualización de los registros en la consola de Lambda
Puede utilizar la consola de Lambda para ver la salida del registro después de invocar una función de Lambda.
Si su código se puede probar desde el editor de **código** integrado, encontrará los registros en los **resultados de ejecución**. Cuando utilice la característica de prueba de la consola para invocar una función, encontrará la **Salida de registro** en la sección de **Detalles**.
## Visualización de los registros de en la consola de CloudWatch
Puede utilizar la consola Amazon CloudWatch para ver los registros de todas las invocaciones de funciones de Lambda.
**Visualización de los registros en la consola CloudWatch**
1. En la consola de CloudWatch, abra la [página de grupos de registro](https://console.aws.amazon.com/cloudwatch/home?#logs:).
1. Seleccione el grupo de registros para su función (**/aws/lambda/*your-function-name***).
1. Elija una secuencia de registro.
Cada flujo de registro se corresponde con una [instancia de su función](lambda-runtime-environment.md). Aparece un flujo de registro cuando actualiza la función de Lambda y cuando se crean instancias adicionales para gestionar invocaciones simultáneas. Para encontrar registros para una invocación específica, le recomendamos que interfiera su función con AWS X-Ray. X-Ray registra los detalles sobre la solicitud y el flujo de registro en el seguimiento.
## Visualización de los registros mediante la AWS Command Line Interface (AWS CLI)
La AWS CLI es una herramienta de código abierto que lo habilita para interactuar con los servicios de AWS mediante el uso de comandos en el intérprete de comandos de la línea de comandos. Para completar los pasos de esta sección, debe disponer de la [versión 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Puede utilizar la [CLI de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) para recuperar registros de una invocación mediante la opción de comando `--log-type`. La respuesta contiene un campo `LogResult` que contiene hasta 4 KB de registros con codificación base64 a partir de la invocación.
**Example recuperar un ID de registro**
En el ejemplo siguiente se muestra cómo recuperar un *ID de registro* del campo `LogResult` para una función denominada `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail
```
Debería ver los siguientes datos de salida:
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example decodificar los registros**
En el mismo símbolo del sistema, utilice la utilidad `base64` para decodificar los registros. En el ejemplo siguiente se muestra cómo recuperar registros codificados en base64 para `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
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*.
Debería ver los siguientes datos de salida:
```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB
```
La utilidad `base64` está disponible en Linux, macOS y [Ubuntu en Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Es posible que los usuarios de macOS necesiten usar `base64 -D`.
**Example get-logs.sh script**
En el mismo símbolo del sistema, utilice el siguiente script para descargar los últimos cinco eventos de registro. El script utiliza `sed` para eliminar las comillas del archivo de salida y permanece inactivo durante 15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de Lambda y la salida del comando `get-log-events`.
Copie el contenido de la siguiente muestra de código y guárdelo en su directorio de proyecto Lambda como `get-logs.sh`.
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*.
```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```
**Example macOS y Linux (solamente)**
En el mismo símbolo del sistema, es posible que los usuarios de macOS y Linux necesiten ejecutar el siguiente comando para asegurarse de que el script es ejecutable.
```
chmod -R 755 get-logs.sh
```
**Example recuperar los últimos cinco eventos de registro**
En el mismo símbolo del sistema, ejecute el siguiente script para obtener los últimos cinco eventos de registro.
```
./get-logs.sh
```
Debería ver los siguientes datos de salida:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```
## Eliminación de registros
Los grupos de registro no se eliminan automáticamente cuando se elimina una función. Para evitar almacenar registros indefinidamente, elimine el grupo de registros o [configure un periodo de retención](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) después de lo cual los registros se eliminan automáticamente.
## Trabajo con la biblioteca logger en Ruby
La [biblioteca logger](https://ruby-doc.org/stdlib-2.7.0/libdoc/logger/rdoc/index.html) de Ruby devuelve registros optimizados que se leen fácilmente. Utilice la utilidad de logger para generar información detallada, mensajes y códigos de error relacionados con su función.
```
# lambda_function.rb
require 'logger'
def handler(event:, context:)
logger = Logger.new($stdout)
logger.info('## ENVIRONMENT VARIABLES')
logger.info(ENV.to_a)
logger.info('## EVENT')
logger.info(event)
event.to_a
end
```
La salida de `logger` incluye el nivel de registro, la marca de tiempo y el ID de la solicitud.
```
START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT VARIABLES
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key': 'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled: true
```
# Instrumentación del código Ruby en AWS Lambda
Lambda se integra con AWS X-Ray para permitirle rastrear, depurar y optimizar las aplicaciones de Lambda. Puede utilizar X-Ray para rastrear una solicitud a medida que esta recorre los recursos de la aplicación, desde el frontend de la API hasta el almacenamiento y la base de datos del backend. Solo con agregar la biblioteca SDK de X-Ray a la configuración de compilación, puede registrar los errores y la latencia de cualquier llamada que realice la función a un servicio de AWS.
Después de configurar el seguimiento activo, se pueden observar solicitudes específicas a través de la aplicación. El [gráfico de servicios de X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) muestra información sobre la aplicación y todos sus componentes. En el siguiente ejemplo, se muestra una aplicación con dos funciones. La función principal procesa eventos y, a veces, devuelve errores. La segunda función de la cadena procesa los errores que aparecen en el primer grupo de registros y utiliza el SDK de AWS para llamar a X-Ray, Amazon Simple Storage Service (Amazon S3) y Registros de Amazon CloudWatch.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
Para activar el seguimiento activo de la función Lambda mediante la consola, siga estos pasos:
**Cómo activar el seguimiento activo**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Elija **Configuration** (Configuración), y luego **Monitoring and operations tools** (Herramientas de supervisión y operaciones).
1. En **Herramientas de monitorización adicionales**, elija **Editar**.
1. En **CloudWatch Application Signals y AWS X-Ray**, seleccione **Habilitar** para **Seguimientos de servicios de Lambda**.
1. Seleccione **Save**.
**Precios**
Puede utilizar el seguimiento de X-Ray de manera gratuita cada mes hasta un límite determinado como parte del nivel Gratuito de AWS. A partir de ese umbral, X-Ray realiza cargos por almacenamiento y recuperación del seguimiento. Para más información, consulte [Precios de AWS X-Ray](https://aws.amazon.com/xray/pricing/).
La función necesita permiso para cargar datos de rastreo en X-Ray. Cuando activa el rastreo activo en la consola de Lambda, Lambda agrega los permisos necesarios al [rol de ejecución](lambda-intro-execution-role.md) de la función. De lo contrario, agregue la política [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess) al rol de ejecución.
X-Ray no sigue todas las solicitudes realizadas a la aplicación. X-Ray aplica un algoritmo de muestreo para garantizar que el seguimiento sea eficiente, a la vez que proporciona una muestra representativa de todas las solicitudes. La tasa de muestreo es 1 solicitud por segundo y un 5 por ciento de las solicitudes adicionales. La frecuencia de muestreo de X-Ray no se puede configurar para las funciones.
En X-Ray, un *seguimiento* registra información sobre una solicitud procesada por uno o varios *servicios*. Lambda registra 2 segmentos por seguimiento, lo que crea dos nodos en el gráfico de servicios. La siguiente imagen resalta estos dos nodos:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/xray-servicemap-function.png)
El primer nodo, situado a la izquierda, representa el servicio de Lambda, que recibe la solicitud de invocación. El segundo nodo representa la función Lambda específica. En el siguiente ejemplo, se muestra un seguimiento con estos dos segmentos. Ambos se denominan **my-function**, pero uno tiene un origen de `AWS::Lambda` y el otro tiene origen de `AWS::Lambda::Function`. Si el segmento `AWS::Lambda` muestra un error, el servicio Lambda tuvo un problema. Si el segmento `AWS::Lambda::Function` muestra un error, la función tuvo un problema.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
En este ejemplo, el segmento `AWS::Lambda::Function` aparece ampliado para mostrar los tres subsegmentos.
**nota**
AWS está implementando cambios en el servicio Lambda. Debido a estos cambios, es posible que vea pequeñas diferencias entre la estructura y el contenido de los mensajes de registro del sistema y los segmentos de rastro emitidos por diferentes funciones de Lambda en su Cuenta de AWS.
El rastro de ejemplo que se muestra aquí ilustra el segmento de función de estilo antiguo. Las diferencias entre los segmentos de estilo antiguo y nuevo se describen en los párrafos siguientes.
Estos cambios se implementarán en las próximas semanas y todas las funciones de todas las Regiones de AWS, excepto en las regiones de China y GovCloud, pasarán a utilizar el nuevo formato de mensajes de registro y segmentos de rastro.
El segmento de función de estilo antiguo contiene los siguientes subsegmentos:
+ **Inicialización**: representa el tiempo dedicado a cargar la función y ejecutar el [código de inicialización](foundation-progmodel.md). Este subsegmento aparece únicamente para el primer evento que procesa cada instancia de la función.
+ **Invocación**: representa el tiempo dedicado a ejecutar el código del controlador.
+ **Sobrecarga**: representa el tiempo que el tiempo de ejecución de Lambda dedica a prepararse para gestionar el siguiente evento.
El segmento de función de estilo nuevo no contiene ningún subsegmento de `Invocation`. En cambio, los subsegmentos de clientes se adjuntan directamente al segmento de la función. Para obtener más información sobre la estructura de los segmentos de funciones de estilo antiguo y nuevo, consulte [Comprensión de los rastros](services-xray.md#services-xray-traces).
Puede instrumentar el código de controlador para registrar metadatos y rastrear llamadas descendentes. Para registrar detalles sobre las llamadas que su controlador realiza a otros recursos y servicios, use el X-Ray SDK para Ruby. Para obtener el SDK, agregue el paquete `aws-xray-sdk` a las dependencias de la aplicación.
**Example [blank-ruby/function/Gemfile](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/function/Gemfile)**
```
# Gemfile
source 'https://rubygems.org'
gem 'aws-xray-sdk', '0.11.4'
gem 'aws-sdk-lambda', '1.39.0'
gem 'test-unit', '3.3.5'
```
Para instrumentar clientes de AWS SDK, se requiere el módulo `aws-xray-sdk/lambda` después de crear un cliente en el código de inicialización.
**Example [blank-ruby/function/lambda\$1function.rb](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/function/lambda_function.rb): seguimiento de un cliente SDK de AWS.**
```
# lambda_function.rb
require 'logger'
require 'json'
require 'aws-sdk-lambda'
$client = Aws::Lambda::Client.new()
$client.get_account_settings()
require 'aws-xray-sdk/lambda'
def lambda_handler(event:, context:)
logger = Logger.new($stdout)
...
```
En X-Ray, un *seguimiento* registra información sobre una solicitud procesada por uno o varios *servicios*. Lambda registra 2 segmentos por seguimiento, lo que crea dos nodos en el gráfico de servicios. La siguiente imagen resalta estos dos nodos:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/xray-servicemap-function.png)
El primer nodo, situado a la izquierda, representa el servicio de Lambda, que recibe la solicitud de invocación. El segundo nodo representa la función Lambda específica. En el siguiente ejemplo, se muestra un seguimiento con estos dos segmentos. Ambos se denominan **my-function**, pero uno tiene un origen de `AWS::Lambda` y el otro tiene origen de `AWS::Lambda::Function`. Si el segmento `AWS::Lambda` muestra un error, el servicio Lambda tuvo un problema. Si el segmento `AWS::Lambda::Function` muestra un error, la función tuvo un problema.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
En este ejemplo, el segmento `AWS::Lambda::Function` aparece ampliado para mostrar los tres subsegmentos.
**nota**
AWS está implementando cambios en el servicio Lambda. Debido a estos cambios, es posible que vea pequeñas diferencias entre la estructura y el contenido de los mensajes de registro del sistema y los segmentos de rastro emitidos por diferentes funciones de Lambda en su Cuenta de AWS.
El rastro de ejemplo que se muestra aquí ilustra el segmento de función de estilo antiguo. Las diferencias entre los segmentos de estilo antiguo y nuevo se describen en los párrafos siguientes.
Estos cambios se implementarán en las próximas semanas y todas las funciones de todas las Regiones de AWS, excepto en las regiones de China y GovCloud, pasarán a utilizar el nuevo formato de mensajes de registro y segmentos de rastro.
El segmento de función de estilo antiguo contiene los siguientes subsegmentos:
+ **Inicialización**: representa el tiempo dedicado a cargar la función y ejecutar el [código de inicialización](foundation-progmodel.md). Este subsegmento aparece únicamente para el primer evento que procesa cada instancia de la función.
+ **Invocación**: representa el tiempo dedicado a ejecutar el código del controlador.
+ **Sobrecarga**: representa el tiempo que el tiempo de ejecución de Lambda dedica a prepararse para gestionar el siguiente evento.
El segmento de función de estilo nuevo no contiene ningún subsegmento de `Invocation`. En cambio, los subsegmentos de clientes se adjuntan directamente al segmento de la función. Para obtener más información sobre la estructura de los segmentos de funciones de estilo antiguo y nuevo, consulte [Comprensión de los rastros](services-xray.md#services-xray-traces).
También puede instrumentar clientes HTTP, registrar consultas SQL y crear subsegmentos personalizados con anotaciones y metadatos. Para obtener más información, consulte [El X-Ray SDK para Ruby](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-ruby.html) en la Guía para desarrolladores de AWS X-Ray.
**Topics**
+ [
## Habilitación del seguimiento activo con la API de Lambda
](#ruby-tracing-api)
+ [
## Habilitación del seguimiento activo con CloudFormation
](#ruby-tracing-cloudformation)
+ [
## Almacenamiento de dependencias en tiempo de ejecución en una capa
](#ruby-tracing-layers)
## Habilitación del seguimiento activo con la API de Lambda
Para administrar la configuración de seguimiento con la AWS CLI o el AWS SDK, utilice las siguientes operaciones de API:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
El siguiente comando de ejemplo de la AWS CLI habilita el seguimiento activo en una función llamada **my-function**.
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
El modo de seguimiento forma parte de la configuración específica de la versión, cuando se publica una versión de la función. No se puede cambiar el modo de seguimiento de una versión publicada.
## Habilitación del seguimiento activo con CloudFormation
Para activar el seguimiento en un recurso de `AWS::Lambda::Function` de una plantilla de CloudFormation, utilice la propiedad `TracingConfig`.
**Example [función-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml): configuración de rastreo**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Para un recurso AWS Serverless Application Model de AWS SAM (`AWS::Serverless::Function`) , utilice la propiedad `Tracing`.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml): configuración de rastreo**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Almacenamiento de dependencias en tiempo de ejecución en una capa
Si utiliza el X-Ray SDK para instrumentar el código de las funciones de los clientes del SDK de AWS, el paquete de implementación puede llegar a ser bastante grande. Para evitar que se carguen dependencias en tiempo de ejecución cada vez que se actualice el código de las funciones, empaquete el X-Ray SDK en una [capa de Lambda](chapter-layers.md).
En el ejemplo siguiente, se muestra un recurso de `AWS::Serverless::LayerVersion` que almacena el X-Ray SDK para Ruby.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/template.yml): capa de dependencias.**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
Properties:
LayerName: blank-ruby-lib
Description: Dependencies for the blank-ruby sample app.
ContentUri: lib/.
CompatibleRuntimes:
- ruby2.5
```
Con esta configuración, solo se actualiza la capa de la biblioteca si se modifican las dependencias del tiempo de ejecución. Dado que el paquete de implementación de la función contiene únicamente el código, esto puede ayudar a reducir los tiempos de carga.
Para crear una capa de dependencias, es necesario realizar cambios en la compilación para generar el archivo de capas antes de la implementación. Para ver un ejemplo de trabajo, consulte la aplicación de ejemplo [blank-ruby](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby).