Empaqueter le contenu de votre couche Création de la couche dans Lambda Utiliser des gemmes provenant de couches dans une fonction Ajoutez 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éation de la couche dans Lambda
Utiliser des gemmes provenant de couches dans une fonction
Ajoutez la couche à votre fonction
Exemple d'application

Empaqueter le contenu de votre couche

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

Créez la couche en utilisant 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 le runtime 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ù se x.x.x trouve votre version de Ruby, par exemple3.4.0)
- ruby/lib
Pour de plus amples informations, veuillez consulter 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 gemmes Ruby tierces ou vos propres modules et classes Ruby. De nombreuses gemmes Ruby populaires contiennent des extensions natives (code C) qui doivent être compilées pour l'environnement Lambda Linux.

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

Pour créer une couche à l'aide de pierres précieuses en rubis pur

Créez un Gemfile pour spécifier les gemmes de rubis purs que vous souhaitez inclure dans votre couche :
Exemple Gemfile
```
source 'https://rubygems.org'

gem 'tzinfo'
```
Installez les gemmes dans le vendor/bundle répertoire à 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 :
Linux/macOS
```
zip -r layer.zip ruby/
```
PowerShell
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
La structure de répertoire de votre fichier .zip doit ressembler à ceci :
```
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 avoir besoin de chaque gemme individuellement dans votre code de fonction. Vous ne pouvez pas utiliser bundler/setup ouBundler.require. Pour de plus amples informations, veuillez consulter Utiliser des gemmes provenant de couches dans une fonction.

De nombreuses gemmes Ruby populaires contiennent des extensions natives (code C) qui doivent être compilées pour la plate-forme cible. Les gemmes populaires dotées d'extensions natives incluent nokogiri, pg, mysql2, sqlite3 et ffi. Ces gemmes doivent être créées dans un environnement Linux compatible avec le runtime Lambda.

Pour créer une couche à l'aide de gemmes avec des extensions natives

Créez un Gemfile.

Exemple Gemfile


source 'https://rubygems.org'

gem 'nokogiri'
gem 'httparty'

Utilisez Docker pour créer les gemmes dans un environnement Linux compatible avec Lambda. Spécifiez une image AWS de base 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 gemmes dans l'environnement Linux approprié et copie le layer.zip fichier dans votre répertoire local. La structure de répertoire de votre fichier .zip doit ressembler à ceci :

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

Vous devez avoir besoin de chaque gemme individuellement dans votre code de fonction. Vous ne pouvez pas utiliser bundler/setup ouBundler.require. Pour de plus amples informations, veuillez consulter Utiliser des gemmes provenant de couches dans une fonction.

Pour créer une couche à l'aide de votre propre code

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

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

Exemple ruby/lib/order_validateur.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 doit ressembler à ceci :

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

Dans votre fonction, exigez et utilisez les modules. Vous devez avoir besoin de chaque gemme individuellement dans votre code de fonction. Vous ne pouvez pas utiliser bundler/setup ouBundler.require. Pour de plus amples informations, veuillez consulter Utiliser des gemmes 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 pour appeler 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éation de la couche dans Lambda

Vous pouvez publier votre couche à l'aide de la console Lambda AWS CLI ou de la console Lambda.

Utiliser des gemmes provenant de couches dans une fonction

Dans votre code de fonction, vous devez explicitement exiger chaque gemme que vous souhaitez utiliser. Les commandes du bundler telles que bundler/setup et ne Bundler.require sont pas prises en charge. Voici comment utiliser correctement les gemmes 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

Ajoutez 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 du AWS Lambda Developer Guide. GitHub 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

Pour créer une couche à l'aide de pierres précieuses en rubis pur

Exemple Gemfile

Note

Pour créer une couche à l'aide de gemmes avec des extensions natives

Exemple Gemfile

Exemple Dockerfile pour Ruby 3.4

Note

Pour créer une couche à l'aide de votre propre code

Exemple ruby/lib/order_validateur.rb

Création de la couche dans Lambda

Pour créer une couche (console)

Utiliser des gemmes provenant de couches dans une fonction

Ajoutez la couche à votre fonction

Pour ajouter une couche à une fonction

Note

Exemple d'application