Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Arbeiten mit Ebenen für Ruby Lambda-Funktionen
Verwenden Sie [Lambda-Ebenen](chapter-layers.md), um Code und Abhängigkeiten zu bündeln, die Sie für mehrere Funktionen wiederverwenden möchten. Ebenen enthalten üblicherweise Bibliotheksabhängigkeiten, eine [benutzerdefinierte Laufzeit](runtimes-custom.md) oder Konfigurationsdateien. Das Erstellen einer Ebene umfasst drei allgemeine Schritte:
1. Verpacken Ihres Ebeneninhalts. Dies bedeutet, dass Sie ein .zip-Dateiarchiv erstellen, das die Abhängigkeiten enthält, die Sie in Ihren Funktionen verwenden möchten.
1. Erstellen Sie die Ebene in Lambda.
1. Fügen Sie die Ebene zu Ihren Funktionen hinzu.
**Topics**
+ [Verpacken Ihres Ebeneninhalts](#ruby-layers-package)
+ [Erstellen Sie die Ebene in Lambda](#publishing-layer)
+ [Verwenden von Gems aus Ebenen in einer Funktion](#ruby-layers-bundler-limitations)
+ [Fügen Sie die Ebene zu Ihrer Funktion hinzu](#ruby-layer-adding)
+ [Beispiel-App](#ruby-layer-sample-app)
## Verpacken Ihres Ebeneninhalts
Um eine Ebene zu erstellen, bündeln Sie Ihre Pakete in einem ZIP-Dateiarchiv, das die folgenden Anforderungen erfüllt:
+ Erstellen Sie die Ebene mithilfe derselben Version von Ruby, die Sie für die Lambda-Funktion verwenden möchten. Wenn Sie beispielsweise Ihre Ebene für Ruby 3.4 erstellen, verwenden Sie die Laufzeit Ruby 3.4 für Ihre Funktion.
+ Die ZIP-Datei Ihrer Ebene muss eine der folgenden Verzeichnisstrukturen verwenden:
+ `ruby/gems/x.x.x` (wobei *x.x.x* Ihre Ruby-Version ist, z. B. `3.4.0`)
+ `ruby/lib`
Weitere Informationen finden Sie unter [Ebenenpfade für jede Lambda-Laufzeit](packaging-layers.md#packaging-layers-paths).
+ Die Pakete in Ihrer Ebene müssen mit Linux kompatibel sein. Lambda-Funktionen werden auf Amazon Linux ausgeführt.
Sie können Ebenen erstellen, die entweder Ruby-Gems von Drittanbietern oder Ihre eigenen Ruby-Module und -Klassen enthalten. Viele beliebte Ruby-Gems enthalten native Erweiterungen (C-Code), die für die Lambda-Linux-Umgebung kompiliert werden müssen.
### Reine Ruby-Gems
Reine Ruby-Gems enthalten nur Ruby-Code und müssen nicht kompiliert werden. Diese Gems lassen sich einfacher verpacken und funktionieren plattformübergreifend.
**So erstellen Sie eine Ebene mit reinen Ruby-Gems**
1. Erstellen Sie eine `Gemfile`, um die reinen Ruby-Gems anzugeben, die Sie in Ihre Ebene aufnehmen möchten:
**Example Gemfile**
```
source 'https://rubygems.org'
gem 'tzinfo'
```
1. Installieren Sie die Gems mit Bundler in einem `vendor/bundle`-Verzeichnis:
```
bundle config set --local path vendor/bundle
bundle install
```
1. Kopieren Sie die installierten Gems in die Verzeichnisstruktur, die Lambda benötigt (`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. Verpacken Sie den Ebeneninhalt:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
Die Verzeichnisstruktur Ihrer ZIP-Datei sollte wie folgt aussehen:
```
ruby/
└── gems/
└── 3.4.0/
├── gems/
│ ├── concurrent-ruby-1.3.5/
│ └── tzinfo-2.0.6/
├── specifications/
├── cache/
├── build_info/
└── (other bundler directories)
```
**Anmerkung**
Sie müssen jede Gem einzeln in Ihrem Funktionscode als erforderlich festlegen. Sie können nicht `bundler/setup` oder `Bundler.require` verwenden. Weitere Informationen finden Sie unter [Verwenden von Gems aus Ebenen in einer Funktion](#ruby-layers-bundler-limitations).
### Gems mit nativen Erweiterungen
Viele beliebte Ruby-Gems enthalten native Erweiterungen (C-Code), die für die Zielplattform kompiliert werden müssen. Beliebte Gems mit nativen Erweiterungen sind unter anderem [nokogiri](https://rubygems.org/gems/nokogiri/), [pg](https://rubygems.org/gems/pg/), [mysql2](https://rubygems.org/gems/mysql2/), [sqlite3](https://rubygems.org/gems/sqlite3/) und [ffi](https://rubygems.org/gems/ffi/). Diese Gems müssen in einer Linux-Umgebung erstellt werden, die mit der Lambda-Laufzeit kompatibel ist.
**So erstellen Sie eine Ebene mit Gems mit nativen Erweiterungen**
1. Erstellen eines `Gemfile`.
**Example Gemfile**
```
source 'https://rubygems.org'
gem 'nokogiri'
gem 'httparty'
```
1. Verwenden Sie Docker, um die Gems in einer Linux-Umgebung zu erstellen, die mit Lambda kompatibel ist. Geben Sie ein [AWS-Basisabbild](ruby-image.md#ruby-image-base) in Ihrem Dockerfile an:
**Example Dockerfile für 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. Erstellen Sie das Bild und extrahieren Sie die Ebene:
```
docker build -t ruby-layer-builder .
docker run --rm -v $(pwd):/output --entrypoint cp ruby-layer-builder layer.zip /output/
```
Dadurch werden die Gems in der richtigen Linux-Umgebung erstellt und die `layer.zip`-Datei in Ihr lokales Verzeichnis kopiert. Die Verzeichnisstruktur Ihrer ZIP-Datei sollte wie folgt aussehen:
```
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)
```
**Anmerkung**
Sie müssen jede Gem einzeln in Ihrem Funktionscode als erforderlich festlegen. Sie können nicht `bundler/setup` oder `Bundler.require` verwenden. Weitere Informationen finden Sie unter [Verwenden von Gems aus Ebenen in einer Funktion](#ruby-layers-bundler-limitations).
### Benutzerdefinierte Ruby-Module
**So erstellen Sie eine Ebene mithilfe Ihres eigenen Codes**
1. Erstellen Sie die erforderliche Verzeichnisstruktur für Ihre Ebene:
```
mkdir -p ruby/lib
```
1. Erstellen Sie Ihre Ruby-Module im `ruby/lib`-Verzeichnis. Das folgende Beispielmodul validiert Bestellungen, indem es überprüft, ob sie die erforderlichen Informationen enthalten.
**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. Verpacken Sie den Ebeneninhalt:
------
#### [ Linux/macOS ]
```
zip -r layer.zip ruby/
```
------
#### [ PowerShell ]
```
Compress-Archive -Path .\ruby -DestinationPath .\layer.zip
```
------
Die Verzeichnisstruktur Ihrer ZIP-Datei sollte wie folgt aussehen:
```
ruby/
└── lib/
└── order_validator.rb
```
1. Fordern Sie in Ihrer Funktion die Module an und verwenden Sie sie. Sie müssen jede Gem einzeln in Ihrem Funktionscode als erforderlich festlegen. Sie können nicht `bundler/setup` oder `Bundler.require` verwenden. Weitere Informationen finden Sie unter [Verwenden von Gems aus Ebenen in einer Funktion](#ruby-layers-bundler-limitations). Beispiel:
```
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
```
Sie können das folgende [Testereignis](testing-functions.md#invoke-with-event) verwenden, um die Funktion aufzurufen:
```
{
"body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
}
```
Erwartete Antwort:
```
{
"statusCode": 200,
"body": "{\"message\":\"Order validated successfully\",\"order\":{\"product_id\":\"ABC123\",\"quantity\":2,\"shipping_priority\":\"express\"}}"
}
```
## Erstellen Sie die Ebene in Lambda
Sie können Ihre Ebene entweder über die AWS CLI oder die Lambda-Konsole veröffentlichen.
------
#### [ AWS CLI ]
Führen Sie den AWS CLI-Befehl [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) aus, um die Lambda-Ebene zu erstellen:
```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes ruby3.4
```
Der Parameter [Kompatible Laufzeiten](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) ist optional. Wenn angegeben, verwendet Lambda diesen Parameter zum Filtern von Ebenen in der Lambda-Konsole.
------
#### [ Console ]
**So erstellen Sie eine Ebene (Konsole)**
1. Öffnen Sie die Seite [Ebenen](https://console.aws.amazon.com/lambda/home#/layers) der Lambda-Konsole.
1. Wählen Sie **Create Layer (Ebene erstellen)** aus.
1. Wählen Sie **ZIP-Datei hochladen** und laden Sie dann das zuvor erstellte ZIP-Archiv hoch.
1. (Optional) Wählen Sie für **Kompatible Laufzeiten** die Ruby-Laufzeit aus, die der Ruby-Version entspricht, mit der Sie die Ebene erstellt haben.
1. Wählen Sie **Erstellen** aus.
------
## Verwenden von Gems aus Ebenen in einer Funktion
In Ihrem Funktionscode müssen Sie jedes Gem, das Sie verwenden möchten, explizit als erforderlich festlegen. Bundler-Befehle wie `bundler/setup` und `Bundler.require` werden nicht unterstützt. So verwenden Sie Gems aus einer Ebene in einer Lambda-Funktion:
```
# 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
```
## Fügen Sie die Ebene zu Ihrer Funktion hinzu
------
#### [ AWS CLI ]
Führen Sie den AWS CLI-Befehl [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) aus, um die Ebene Ihrer Funktion hinzuzufügen. Verwenden Sie den ARN der Ebene für den `--layers`-Parameter. Der ARN muss die Version angeben (z. B. `arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`). Weitere Informationen finden Sie unter [Ebenen und Ebenenversionen](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"
```
Die **cli-binary-format**-Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie `aws configure set cli-binary-format raw-in-base64-out` aus. Weitere Informationen finden Sie unter [Von AWS CLI unterstützte globale Befehlszeilenoptionen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) im *AWS Command Line Interface-Benutzerhandbuch für Version 2*.
------
#### [ Console ]
**So fügen Sie eine Ebene zu einer Funktion hinzu**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion aus.
1. Blättern Sie nach unten bis zum Abschnitt **Ebenen** und wählen Sie dann **Eine Ebene hinzufügen**.
1. Wählen Sie unter **Ebene auswählen** die Option **Benutzerdefinierte Ebenen** und dann Ihre Ebene aus.
**Anmerkung**
Wenn Sie bei der Erstellung der Ebene keine [kompatible Laufzeit](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) hinzugefügt haben, wird die Ebene hier nicht aufgeführt. Sie können stattdessen den ARN der Ebene angeben.
1. Wählen Sie **Hinzufügen** aus.
------
## Beispiel-App
Weitere Beispiele für die Verwendung von Lambda-Ebenen finden Sie in der Beispielanwendung [layer-ruby](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-ruby) im GitHub-Repository des AWS Lambda-Entwicklerhandbuchs. Diese Anwendung enthält eine Ebene, die die [tzinfo](https://rubygems.org/gems/tzinfo)-Bibliothek enthält. Nach dem Erstellen der Ebene können Sie die entsprechende Funktion bereitstellen und aufrufen, um zu bestätigen, dass die Ebene wie erwartet funktioniert.