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 livello 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 livello, raggruppa i pacchetti in un archivio di file con estensione zip che soddisfi i seguenti requisiti:
+ Create il livello utilizzando la stessa versione di Ruby che intendete utilizzare per la funzione Lambda. Ad esempio, se create il vostro layer per Ruby 3.4, usate il runtime Ruby 3.4 per la vostra funzione.
+ Il file.zip del livello deve utilizzare una di queste strutture di directory:
+ `ruby/gems/x.x.x`(dove *x.x.x* è la vostra 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 di ruby puro
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.
**Creazione di un livello utilizzando gemme di Ruby puri**
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 dei livelli:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
L'aspetto della struttura di directory dovrebbe essere simile al 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 è possibile utilizzare `bundler/setup` con `Bundler.require`. Per ulteriori informazioni, consulta [Usare le gemme dei livelli in una funzione](#ruby-layers-bundler-limitations).
### Gems 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.
**Creazione di un livello utilizzando gemme con estensioni native**
1. Creazione di un del `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 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. 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. L'aspetto della struttura di directory dovrebbe essere simile al seguente:
```
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 gem singolarmente nel codice della funzione. Non è possibile utilizzare `bundler/setup` con `Bundler.require`. Per ulteriori informazioni, consulta [Usare le gemme dei livelli in una funzione](#ruby-layers-bundler-limitations).
### Moduli di Ruby personalizzati
**Creazione di un livello utilizzando il tuo 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\$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. Comprimi il contenuto dei livelli:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
L'aspetto della struttura di directory dovrebbe essere simile al 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 è possibile utilizzare `bundler/setup` con `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 i seguenti dati evento per [invocare la funzione](testing-functions.md#invoke-with-event):
```
{
"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 livello in Lambda.
È possibile creare la funzione Lambda mediante la 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 ruby3.4
```
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. Seleziona **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 [AWS CLIupdate-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html). Usa l'attività ARN per il parametro `--layers`. 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'opzione **cli-binary-format** è necessaria se si utilizza la versione 2 della AWS CLI. 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. Scegli **Aggiungi**.
------
## app di esempio
Per altri esempi di utilizzo dei layer Lambda, consulta l'applicazione di esempio [layer-ruby nel repository](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-ruby) GitHub della Developer AWS Lambda Guide. [Questa applicazione include un livello che contiene la libreria tzinfo.](https://rubygems.org/gems/tzinfo) Dopo aver creato un livello, puoi implementare e richiamare la funzione corrispondente per verificare che tutto funzioni.