Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Utilisation de couches pour les fonctions Lambda Ruby Utilisez les [couches Lambda](chapter-layers.md) 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](runtimes-custom.md), ou des fichiers de configuration. La création d’une couche implique trois étapes générales : 1. 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. 1. Créez la couche dans Lambda. 1. Ajoutez la couche à vos fonctions. **Topics** + [ ## Empaqueter le contenu de votre couche ](#ruby-layers-package) + [ ## Créer la couche dans Lambda ](#publishing-layer) + [ ## Utiliser des gems provenant de couches dans une fonction ](#ruby-layers-bundler-limitations) + [ ## Ajouter la couche à votre fonction ](#ruby-layer-adding) + [ ## Exemple d’application ](#ruby-layer-sample-app) ## 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](packaging-layers.md#packaging-layers-paths). + 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. ### Gems Ruby pures 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** 1. Créez un `Gemfile` pour spécifier les gems Ruby pures que vous souhaitez inclure dans votre couche : **Example Gemfile** ``` source 'https://rubygems.org' gem 'tzinfo' ``` 1. Installez les gems dans le répertoire `vendor/bundle` à l’aide de Bundler : ``` bundle config set --local path vendor/bundle bundle install ``` 1. 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/ ``` 1. 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 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](#ruby-layers-bundler-limitations). ### Gems avec des extensions natives 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](https://rubygems.org/gems/nokogiri/), [pg](https://rubygems.org/gems/pg/), [mysql2](https://rubygems.org/gems/mysql2/), [sqlite3](https://rubygems.org/gems/sqlite3/), and [ffi](https://rubygems.org/gems/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** 1. Créer un de `Gemfile`. **Example Gemfile** ``` source 'https://rubygems.org' gem 'nokogiri' gem 'httparty' ``` 1. Utilisez Docker pour créer les gems dans un environnement Linux compatible avec Lambda. Spécifiez une [image de base AWS](ruby-image.md#ruby-image-base) dans votre Dockerfile : **Example 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/ ``` 1. 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** 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](#ruby-layers-bundler-limitations). ### Modules Ruby personnalisés **Créer une couche à l’aide de votre propre code** 1. Créez la structure de répertoires requise pour votre couche : ``` mkdir -p ruby/lib ``` 1. 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. **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. 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 devrait se présenter comme suit : ``` ruby/ └── lib/ └── order_validator.rb ``` 1. 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](#ruby-layers-bundler-limitations). 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](testing-functions.md#invoke-with-event) 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. ------ #### [ AWS CLI ] Exécutez la commande AWS CLI [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) pour créer la couche Lambda : ``` aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes ruby3.4 ``` Le paramètre [compatible runtimes](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) est facultatif. Lorsqu’il est spécifié, Lambda utilise ce paramètre pour filtrer les couches dans la console Lambda. ------ #### [ Console ] **Pour créer une couche (console)** 1. Ouvrez la [page Couches](https://console.aws.amazon.com/lambda/home#/layers) de la console Lambda. 1. Sélectionnez **Créer un calque**. 1. Choisissez **Charger un fichier .zip**, puis chargez l’archive .zip que vous avez créée précédemment. 1. (Facultatif) Pour **Environnements d’exécution compatibles**, choisissez l’environnement d’exécution Ruby qui correspond à la version de Ruby que vous avez utilisée pour créer votre couche. 1. Choisissez **Créer**. ------ ## 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 ------ #### [ AWS CLI ] Pour associer la couche à votre fonction, exécutez la commande AWS CLI [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html). Utilisez l’ARN de la couche pour le paramètre `--layers`. L’ARN doit spécifier la version (par exemple, `arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`). Pour de plus amples informations, consultez [Couches et versions de couches](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" ``` L’option **cli-binary-format** est obligatoire si vous utilisez AWS CLI version 2. Pour faire de ce paramètre le paramètre par défaut, exécutez `aws configure set cli-binary-format raw-in-base64-out`. Pour plus d’informations, consultez les [options de ligne de commande globales AWS CLI prises en charge](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) dans le *Guide de l’utilisateur AWS Command Line Interface version 2*. ------ #### [ Console ] **Ajouter une couche à une fonction** 1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda. 1. Choisissez la fonction. 1. Faites défiler jusqu’à la section **Couches**, puis choisissez **Ajouter une couche**. 1. Sous **Choisir une couche**, sélectionnez **Couches personnalisées**, puis choisissez votre couche. **Note** Si vous n’avez pas ajouté d’[environnement d’exécution compatible](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) lors de la création de la couche, celle-ci ne sera pas répertoriée ici. Vous pouvez spécifier l’ARN de la couche à la place. 1. Choisissez **Ajouter**. ------ ## Exemple d’application Pour d’autres exemples d’utilisation des couches Lambda, consultez l’exemple d’application [layer-ruby](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/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](https://rubygems.org/gems/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.