Empaqueter le contenu de votre couche Créer la couche dans Lambda Utiliser des gems provenant de couches dans une fonction Ajouter la couche à votre fonction Exemple d’application

Utilisation de couches pour les fonctions Lambda Ruby

Utilisez les couches Lambda pour empaqueter le code et les dépendances que vous souhaitez réutiliser dans plusieurs fonctions. Les couches contiennent généralement des dépendances de bibliothèque, une exécution personnalisée, ou des fichiers de configuration. La création d’une couche implique trois étapes générales :

Empaquetez le contenu de votre couche. Cela signifie créer une archive de fichiers .zip contenant les dépendances que vous souhaitez utiliser dans vos fonctions.
Créez la couche dans Lambda.
Ajoutez la couche à vos fonctions.

Rubriques

Empaqueter le contenu de votre couche
Créer la couche dans Lambda
Utiliser des gems provenant de couches dans une fonction
Ajouter la couche à votre fonction
Exemple d’application

Empaqueter le contenu de votre couche

Pour créer une couche, regroupez vos packages dans une archive (fichier .zip) répondant aux exigences suivantes :

Créez la couche à l’aide de la même version de Ruby que celle que vous prévoyez d’utiliser pour la fonction Lambda. Par exemple, si vous créez votre couche pour Ruby 3.4, utilisez l’environnement d'exécution Ruby 3.4 pour votre fonction.
Le fichier .zip de votre couche doit utiliser l’une des structures de répertoires suivantes :
- ruby/gems/x.x.x (où x.x.x est votre version de Ruby, par exemple 3.4.0)
- ruby/lib
Pour de plus amples informations, consultez Chemins d’accès de couche pour chaque exécution Lambda.
Les packages de votre couche doivent être compatibles avec Linux. Les fonctions Lambda s’exécutent sur Amazon Linux.

Vous pouvez créer des couches contenant des gems Ruby tierces ou vos propres modules et classes Ruby. De nombreuses gems Ruby populaires contiennent des extensions natives (code C) qui doivent être compilées pour l’environnement Lambda Linux.

Les gems Ruby pures contiennent uniquement du code Ruby et ne nécessitent pas de compilation. Ces gems sont plus simples à empaqueter et à utiliser sur différentes plateformes.

Créer une couche à l’aide de gems Ruby pures

Créez un Gemfile pour spécifier les gems Ruby pures que vous souhaitez inclure dans votre couche :
Exemple Gemfile
```
source 'https://rubygems.org'

gem 'tzinfo'
```
Installez les gems dans le répertoire vendor/bundle à l’aide de Bundler :
```
bundle config set --local path vendor/bundle
bundle install
```
Copiez les gems installées dans la structure de répertoires requise par Lambda (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/
```

Compressez le contenu de la couche :

La structure de répertoire de votre fichier .zip devrait se présenter comme suit :

ruby/              
└── gems/
    └── 3.4.0/
        ├── gems/
        │   ├── concurrent-ruby-1.3.5/
        │   └── tzinfo-2.0.6/
        ├── specifications/
        ├── cache/
        ├── build_info/
        └── (other bundler directories)

Note

Vous devez requérir chaque gem individuellement dans le code de votre fonction. Vous ne pouvez pas utiliser bundler/setup ou Bundler.require. Pour de plus amples informations, consultez Utiliser des gems provenant de couches dans une fonction.

De nombreuses gems Ruby populaires contiennent des extensions natives (code C) qui doivent être compilées pour la plateforme cible. Les gems populaires dotées d’extensions natives incluent nokogiri, pg, mysql2, sqlite3, and ffi. Ces gems doivent être créées dans un environnement Linux compatible avec l’environnement d'exécution Lambda.

Créer une couche à l’aide de gems avec des extensions natives

Créer un de Gemfile.

Exemple Gemfile


source 'https://rubygems.org'

gem 'nokogiri'
gem 'httparty'

Utilisez Docker pour créer les gems dans un environnement Linux compatible avec Lambda. Spécifiez une image de base AWS dans votre Dockerfile :

Exemple Dockerfile pour 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/

Créez l’image et extrayez la couche :


docker build -t ruby-layer-builder .
docker run --rm -v $(pwd):/output --entrypoint cp ruby-layer-builder layer.zip /output/

Cela crée les gems dans l’environnement Linux approprié et copie le fichier layer.zip dans votre répertoire local. La structure de répertoire de votre fichier .zip devrait se présenter comme suit :

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)

Note

Créer une couche à l’aide de votre propre code

Créez la structure de répertoires requise pour votre couche :
```
mkdir -p ruby/lib
```

Créez vos modules Ruby dans le répertoire ruby/lib. L’exemple de module suivant valide les commandes en confirmant qu’elles contiennent les informations requises.

Exemple ruby/lib/order_validator.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

Compressez le contenu de la couche :

La structure de répertoire de votre fichier .zip devrait se présenter comme suit :

ruby/              
└── lib/
    └── order_validator.rb

Dans votre fonction, exigez (require) et utilisez les modules. Vous devez requérir chaque gem individuellement dans le code de votre fonction. Vous ne pouvez pas utiliser bundler/setup ou Bundler.require. Pour de plus amples informations, consultez Utiliser des gems provenant de couches dans une fonction. Exemple :


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

Vous pouvez utiliser l’événement de test suivant afin d’invoquer la fonction :


{
    "body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}

Réponse attendue :


{
  "statusCode": 200,
  "body": "{\"message\":\"Order validated successfully\",\"order\":{\"product_id\":\"ABC123\",\"quantity\":2,\"shipping_priority\":\"express\"}}"
}

Créer la couche dans Lambda

Vous pouvez publier votre couche en utilisant AWS CLI ou la console Lambda.

Utiliser des gems provenant de couches dans une fonction

Dans le code de votre fonction, vous devez explicitement exiger chaque gem que vous souhaitez utiliser. Les commandes Bundler comme bundler/setup et Bundler.require ne sont pas prises en charge. Voici comment utiliser correctement les gems d’une couche dans une fonction Lambda :



# 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

Ajouter la couche à votre fonction

Exemple d’application

Pour d’autres exemples d’utilisation des couches Lambda, consultez l’exemple d’application layer-ruby dans le référentiel GitHub du Guide du développeur AWS Lambda. Cette application inclut une couche qui contient la bibliothèque tzinfo. Après avoir créé la couche, vous pouvez déployer et invoquer la fonction correspondante pour confirmer que la couche fonctionne comme prévu.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Déploiement d’images de conteneur

Contexte

Utilisation de couches pour les fonctions Lambda Ruby

Rubriques

Empaqueter le contenu de votre couche

Créer une couche à l’aide de gems Ruby pures

Exemple Gemfile

Note

Créer une couche à l’aide de gems avec des extensions natives

Exemple Gemfile

Exemple Dockerfile pour Ruby 3.4

Note

Créer une couche à l’aide de votre propre code

Exemple ruby/lib/order_validator.rb

Créer la couche dans Lambda

Pour créer une couche (console)

Utiliser des gems provenant de couches dans une fonction

Ajouter la couche à votre fonction

Ajouter une couche à une fonction

Note

Exemple d’application