Crea un pacchetto per il contenuto del livello Crea il layer in Lambda Usare le gemme dei livelli in una funzione Aggiungi il livello alla tua funzione App di esempio

Utilizzo dei livelli per le funzioni Lamba di Ruby

Usa i livelli Lambda per impacchettare codice e dipendenze che desideri riutilizzare in più funzioni. I livelli di solito contengono dipendenze dalla libreria, un runtime personalizzato o file di configurazione. La creazione di un livello prevede tre passaggi generali:

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.
Crea il livello in Lambda.
Aggiungi il livello alle tue funzioni.

Argomenti

Crea un pacchetto per il contenuto del livello
Crea il layer in Lambda
Usare le gemme dei livelli in una funzione
Aggiungi il livello alla tua funzione
App di esempio

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 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(x.x.xdov'è la tua versione di Ruby, ad esempio) 3.4.0
- ruby/lib
Per ulteriori informazioni, consulta Percorsi dei livelli per ciascun runtime Lambda.
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.

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

Crea uno Gemfile per specificare le gemme Ruby pure che desideri includere nel tuo livello:
Esempio Gemfile
```
source 'https://rubygems.org'

gem 'tzinfo'
```
Installa le gemme nella vendor/bundle directory usando Bundler:
```
bundle config set --local path vendor/bundle
bundle install
```
Copia le gemme installate nella struttura di directory richiesta da Lambdaruby/gems/3.4.0):
```
mkdir -p ruby/gems/3.4.0
cp -r vendor/bundle/ruby/3.4.0*/* ruby/gems/3.4.0/
```

Comprimi il contenuto del livello:

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 oBundler.require. Per ulteriori informazioni, consulta Usare le gemme dei livelli in una funzione.

Molte gemme Ruby popolari contengono estensioni native (codice C) che devono essere compilate per la piattaforma di destinazione. Le gemme popolari con estensioni native includono nokogiri, pg, mysql2, sqlite3 e ffi. Queste gemme devono essere create in un ambiente Linux compatibile con il runtime Lambda.

Per creare un livello utilizzando gemme con estensioni native

Creare un Gemfile.

Esempio Gemfile


source 'https://rubygems.org'

gem 'nokogiri'
gem 'httparty'

Usa Docker per creare le gemme in un ambiente Linux compatibile con Lambda. Specificate un'immagine di AWS base nel vostro Dockerfile:

Esempio 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/

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

Per creare un livello utilizzando il proprio codice

Crea la struttura di directory richiesta per il tuo livello:
```
mkdir -p ruby/lib
```

Crea i tuoi moduli Ruby nella ruby/lib directory. Il seguente modulo di esempio convalida gli ordini confermando che contengono le informazioni richieste.

Esempio 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

Comprimi il contenuto del livello:

La struttura delle cartelle del file.zip dovrebbe essere simile alla seguente:

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

Nella tua funzione, richiedi e usa i moduli. È necessario richiedere ogni gemma singolarmente nel codice della funzione. Non puoi usare bundler/setup oBundler.require. Per ulteriori informazioni, consulta Usare le gemme dei livelli in una funzione. 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 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.

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

App di esempio

Per altri esempi di utilizzo dei layer Lambda, consultate l'applicazione di esempio layer-ruby nel repository Developer Guide. AWS Lambda GitHub Questa applicazione include un livello che contiene la libreria tzinfo. Dopo aver creato il layer, è possibile implementare e richiamare la funzione corrispondente per confermare che il layer funzioni come previsto.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Implementazione di immagini di container

Context

Utilizzo dei livelli per le funzioni Lamba di Ruby

Argomenti

Crea un pacchetto per il contenuto del livello

Per creare un livello usando gemme Ruby pure

Esempio Gemfile

Nota

Per creare un livello utilizzando gemme con estensioni native

Esempio Gemfile

Esempio Dockerfile per Ruby 3.4

Nota

Per creare un livello utilizzando il proprio codice

Esempio ruby/lib/order_validator.rb

Crea il layer in Lambda

Creazione di un livello (console)

Usare le gemme dei livelli in una funzione

Aggiungi il livello alla tua funzione

Per aggiungere un livello a una funzione

Nota

App di esempio