Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo dei livelli per le funzioni Lamba di Ruby
Usa i [livelli Lambda](chapter-layers.md) per impacchettare codice e dipendenze che desideri riutilizzare in più funzioni. I livelli di solito contengono dipendenze dalla libreria, un [runtime personalizzato](runtimes-custom.md) o file di configurazione. La creazione di un livello prevede tre passaggi generali:
1. Crea un pacchetto per il contenuto del livello. Ciò significa creare un archivio di file con estensione .zip che contiene le dipendenze che desideri utilizzare nelle funzioni.
1. Crea il livello in Lambda.
1. Aggiungi il livello alle tue funzioni.
**Topics**
+ [Crea un pacchetto per il contenuto del livello](#ruby-layers-package)
+ [Crea il layer in Lambda](#publishing-layer)
+ [Usare le gemme dei livelli in una funzione](#ruby-layers-bundler-limitations)
+ [Aggiungi il livello alla tua funzione](#ruby-layer-adding)
+ [App di esempio](#ruby-layer-sample-app)
## Crea un pacchetto per il contenuto del livello
Per creare un layer, raggruppa i pacchetti in un archivio di file.zip che soddisfi i seguenti requisiti:
+ Crea il layer utilizzando la stessa versione di Ruby che intendi utilizzare per la funzione Lambda. Ad esempio, se create il vostro layer per Ruby 4.0, usate il runtime Ruby 4.0 per la vostra funzione.
+ Il file.zip del livello deve utilizzare una di queste strutture di directory:
+ `ruby/gems/{{x.x.x}}`({{x.x.x}}dov'è la tua versione di Ruby, ad esempio) `3.4.0`
+ `ruby/lib`
Per ulteriori informazioni, consulta [Percorsi dei livelli per ciascun runtime Lambda](packaging-layers.md#packaging-layers-paths).
+ I pacchetti del livello devono essere compatibili con Linux. Le funzioni Lambda vengono eseguite su Amazon Linux.
Puoi creare livelli che contengono gemme Ruby di terze parti o moduli e classi Ruby personalizzati. Molte gemme Ruby popolari contengono estensioni native (codice C) che devono essere compilate per l'ambiente Lambda Linux.
### Gemme Ruby pure
Le gemme Pure Ruby contengono solo codice Ruby e non richiedono la compilazione. Queste gemme sono più semplici da impacchettare e funzionano su piattaforme diverse.
**Per creare un livello usando gemme Ruby pure**
1. Crea uno `Gemfile` per specificare le gemme Ruby pure che desideri includere nel tuo livello:
**Example Gemfile**
```
source 'https://rubygems.org'
gem 'tzinfo'
```
1. Installa le gemme nella `vendor/bundle` directory usando Bundler:
```
bundle config set --local path vendor/bundle
bundle install
```
1. Copia le gemme installate nella struttura di directory richiesta da 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. Comprimi il contenuto del livello:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
La struttura delle cartelle del file.zip dovrebbe essere simile alla seguente:
```
ruby/
└── gems/
└── 3.4.0/
├── gems/
│ ├── concurrent-ruby-1.3.5/
│ └── {{tzinfo-2.0.6/}}
├── specifications/
├── cache/
├── build_info/
└── (other bundler directories)
```
**Nota**
È necessario richiedere ogni gemma singolarmente nel codice della funzione. Non puoi usare `bundler/setup` o`Bundler.require`. Per ulteriori informazioni, consulta [Usare le gemme dei livelli in una funzione](#ruby-layers-bundler-limitations).
### Gemme con estensioni native
Molte gemme Ruby popolari contengono estensioni native (codice C) che devono essere compilate per la piattaforma di destinazione. [https://rubygems.org/gems/sqlite3/](https://rubygems.org/gems/sqlite3/) Queste gemme devono essere create in un ambiente Linux compatibile con il runtime Lambda.
**Per creare un livello utilizzando gemme con estensioni native**
1. Creare un `Gemfile`.
**Example Gemfile**
```
source 'https://rubygems.org'
gem 'nokogiri'
gem 'httparty'
```
1. Usa Docker per creare le gemme in un ambiente Linux compatibile con Lambda. Specificate un'[immagine di AWS base](ruby-image.md#ruby-image-base) nel vostro Dockerfile:
**Example Dockerfile per Ruby 4.0**
```
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. Costruisci l'immagine ed estrai il livello:
```
docker build -t ruby-layer-builder .
docker run --rm -v $(pwd):/output --entrypoint cp ruby-layer-builder layer.zip /output/
```
Questo crea le gemme nell'ambiente Linux corretto e copia il `layer.zip` file nella directory locale. La struttura delle cartelle del file.zip dovrebbe assomigliare a questa:
```
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**
È necessario richiedere ogni gemma singolarmente nel codice della funzione. Non puoi usare `bundler/setup` o`Bundler.require`. Per ulteriori informazioni, consulta [Usare le gemme dei livelli in una funzione](#ruby-layers-bundler-limitations).
### Moduli Ruby personalizzati
**Per creare un livello utilizzando il proprio codice**
1. Crea la struttura di directory richiesta per il tuo livello:
```
mkdir -p ruby/lib
```
1. Crea i tuoi moduli Ruby nella `ruby/lib` directory. Il seguente modulo di esempio convalida gli ordini confermando che contengono le informazioni richieste.
**Example 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
```
1. Comprimi il contenuto del livello:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
La struttura delle cartelle del file.zip dovrebbe essere simile alla seguente:
```
ruby/
└── lib/
└── order_validator.rb
```
1. Nella tua funzione, richiedi e usa i moduli. È necessario richiedere ogni gemma singolarmente nel codice della funzione. Non puoi usare `bundler/setup` o`Bundler.require`. Per ulteriori informazioni, consulta [Usare le gemme dei livelli in una funzione](#ruby-layers-bundler-limitations). Esempio:
```
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
```
È possibile utilizzare il seguente [evento di test](testing-functions.md#invoke-with-event) per richiamare la funzione:
```
{
"body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}
```
Risposta prevista:
```
{
"statusCode": 200,
"body": "{\"message\":\"Order validated successfully\",\"order\":{\"product_id\":\"ABC123\",\"quantity\":2,\"shipping_priority\":\"express\"}}"
}
```
## Crea il layer in Lambda
È possibile pubblicare il layer utilizzando la console AWS CLI o la console Lambda.
------
#### [ AWS CLI ]
Esegui il AWS CLI comando [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) per creare il livello Lambda:
```
aws lambda publish-layer-version --layer-name {{my-layer}} --zip-file fileb://layer.zip --compatible-runtimes {{ruby4.0}}
```
Il parametro [compatible runtimes è facoltativo](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes). Quando specificato, Lambda utilizza questo parametro per filtrare i livelli nella console Lambda.
------
#### [ Console ]
**Creazione di un livello (console)**
1. Apri la [pagina Layers](https://console.aws.amazon.com/lambda/home#/layers) (Livelli) nella console Lambda.
1. Scegli **Create layer** (Crea livello).
1. Scegli **Carica un file.zip**, quindi carica l'archivio.zip che hai creato in precedenza.
1. (Facoltativo) Per i **runtime compatibili**, scegli il runtime di Ruby che corrisponde alla versione di Ruby che hai usato per creare il tuo layer.
1. Scegli **Create** (Crea).
------
## Usare le gemme dei livelli in una funzione
Nel codice della funzione, è necessario richiedere esplicitamente ogni gemma che si desidera utilizzare. I comandi Bundler come `bundler/setup` e non `Bundler.require` sono supportati. Ecco come usare correttamente le gemme di un livello in una funzione 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
```
## Aggiungi il livello alla tua funzione
------
#### [ AWS CLI ]
Per collegare il layer alla tua funzione, esegui il comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) AWS CLI . Per il `--layers` parametro, utilizzate il livello ARN. L'ARN deve specificare la versione (ad esempio,`arn:aws:lambda:us-east-1:123456789012:layer:my-layer:{{1}}`). Per ulteriori informazioni, consulta [Livelli e versioni di livelli](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'**cli-binary-format**opzione è obbligatoria se si utilizza la AWS CLI versione 2. Per rendere questa impostazione come predefinita, esegui `aws configure set cli-binary-format raw-in-base64-out`. Per ulteriori informazioni, consulta la pagina [AWS CLI supported global command line options](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) nella *Guida per l'utente di AWS Command Line Interface versione 2*.
------
#### [ Console ]
**Aggiunta di un livello a una funzione**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Scegli la funzione.
1. Scorri verso il basso fino alla sezione **Livelli**, quindi scegli **Aggiungi un livello**.
1. In **Scegli un livello**, seleziona **Livelli personalizzati**, quindi scegli il tuo livello.
**Nota**
Se non hai aggiunto un [runtime compatibile](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) quando hai creato il layer, il tuo layer non verrà elencato qui. È possibile specificare invece il livello ARN.
1. Scegliere **Aggiungi**.
------
## App di esempio
Per altri esempi di utilizzo dei layer Lambda, consultate l'applicazione di esempio [layer-ruby](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-ruby) nel repository Developer Guide. AWS Lambda GitHub [Questa applicazione include un livello che contiene la libreria tzinfo.](https://rubygems.org/gems/tzinfo) Dopo aver creato il layer, è possibile implementare e richiamare la funzione corrispondente per confermare che il layer funzioni come previsto.