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.
# Erstellen von Lambda-Funktionen mit Ruby
Sie können Ruby-Code in AWS Lambda ausführen. Lambda bietet [Laufzeiten](lambda-runtimes.md) für Ruby, die Ihren Code ausführen, um Ereignisse zu verarbeiten. Ihr Code wird in einer Umgebung ausgeführt, die die Rolle AWS SDK für Ruby, with credentials from a AWS Identity and Access Management (IAM) enthält, die Sie verwalten. Weitere Informationen zu den SDK-Versionen, die in den Laufzeiten von Ruby enthalten sind, finden Sie unter [SDK-Versionen, die zur Laufzeit enthalten sind](#ruby-sdk-included).
Lambda unterstützt die folgenden Ruby-Laufzeiten.
| Name | ID | Betriebssystem | Datum der Veraltung | Blockfunktion erstellen | Blockfunktion aktualisieren |
| --- | --- | --- | --- | --- | --- |
| Ruby 3.4 | `ruby3.4` | Amazon Linux 2023 | 31. März 2028 | 30. April 2028 | 31. Mai 2028 |
| Ruby 3.3 | `ruby3.3` | Amazon Linux 2023 | 31. März 2027 | 30. April 2027 | 31. Mai 2027 |
| Ruby 3.2 | `ruby3.2` | Amazon Linux 2 | 31. März 2026 | 31. August 2026 | 30. September 2026 |
**So erstellen Sie eine Ruby-Funktion**
1. Öffnen Sie die [Lambda-Konsole](https://console.aws.amazon.com/lambda).
1. Wählen Sie **Funktion erstellen**.
1. Konfigurieren Sie die folgenden Einstellungen:
+ **Funktionsname**: Geben Sie einen Namen für die Funktion ein.
+ **Runtime**: Wählen Sie **Ruby 3.4**.
1. Wählen Sie **Funktion erstellen**.
Die Konsole erstellt eine Lambda-Funktion mit einer einzigen Quelldatei mit dem Namen `lambda_function.rb`. Mit dem integrierten Code-Editor können Sie diese Datei bearbeiten und weitere Dateien hinzufügen. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren. Um Ihren Code auszuführen, wählen Sie anschließend im Abschnitt **TESTEREIGNISSE** die Option **Testereignis erstellen** aus.
Die `lambda_function.rb`-Datei exportiert eine Funktion mit dem Namen `lambda_handler`, die ein Ereignisobjekt und ein Kontext-Objekt übernimmt. Dies ist die [Handler-Funktion](ruby-handler.md), die bei einem Aufruf der Funktion von Lambda aufgerufen wird. Die Ruby-Funktionslaufzeit ruft Aufrufereignisse von Lambda ab und leitet sie an den Handler weiter. In der Konfiguration der Funktion lautet der Wert für den Handler `lambda_function.lambda_handler`.
Wenn Sie Ihren Funktionscode speichern, erstellt die Lambda-Konsole ein Bereitstellungspaket für das ZIP-Dateiarchiv. Wenn Sie Ihren Funktionscode außerhalb der Konsole (mit einer IDE) entwickeln, müssen Sie [ein Bereitstellungspaket erstellen](ruby-package.md), um Ihren Code in die Lambda-Funktion hochzuladen.
Die Funktionslaufzeit übergibt neben dem Aufrufereignis ein Context-Objekt an den Handler. Das [Context-Objekt](ruby-context.md) enthält zusätzliche Informationen zum Aufruf, zur Funktion und zur Ausführungsumgebung. Weitere Informationen erhalten Sie über die Umgebungsvariablen.
Ihre Lambda-Funktion wird mit einer CloudWatch Logs-Protokollgruppe geliefert. Die Funktionslaufzeit sendet Details zu jedem Aufruf an CloudWatch Logs. Es leitet alle [Protokolle weiter, die Ihre Funktion während des Aufrufs ausgibt](ruby-logging.md). Wenn Ihre Funktion einen Fehler zurückgibt, formatiert Lambda den Fehler und gibt ihn an den Aufrufer zurück.
**Topics**
+ [SDK-Versionen, die zur Laufzeit enthalten sind](#ruby-sdk-included)
+ [Aktivieren von Yet Another Ruby JIT (YJIT)](#ruby-yjit)
+ [Definieren des Lambda-Funktions-Handlers in Ruby](ruby-handler.md)
+ [Bereitstellen von Ruby-Lambda-Funktionen mit ZIP-Dateiarchiven](ruby-package.md)
+ [Bereitstellen von Ruby-Lambda-Funktionen mit Container-Images](ruby-image.md)
+ [Arbeiten mit Ebenen für Ruby Lambda-Funktionen](ruby-layers.md)
+ [Verwenden des Lambda-Kontextobjekts zum Abrufen von Ruby-Funktionsinformationen](ruby-context.md)
+ [Ruby-Lambda-Funktionen protokollieren und überwachen](ruby-logging.md)
+ [Instrumentierung von Ruby-Code in AWS Lambda](ruby-tracing.md)
## SDK-Versionen, die zur Laufzeit enthalten sind
Die Version des AWS SDK, die in der Ruby-Runtime enthalten ist, hängt von der Laufzeitversion und Ihrer AWS-Region ab. Das AWS SDK for Ruby ist modular konzipiert und wird durch getrennt AWS-Service. Um die Versionsnummer eines bestimmten Dienst-Gems zu ermitteln, das in der von Ihnen verwendeten Laufzeitumgebung enthalten ist, erstellen Sie eine Lambda-Funktion mit Code in folgendem Format. Ersetzen Sie `aws-sdk-s3` und `Aws::S3` durch den Namen der Service-Gems, die Ihr Code verwendet.
```
require 'aws-sdk-s3'
def lambda_handler(event:, context:)
puts "Service gem version: #{Aws::S3::GEM_VERSION}"
puts "Core version: #{Aws::CORE_GEM_VERSION}"
end
```
## Aktivieren von Yet Another Ruby JIT (YJIT)
Die Ruby-Laufzeiten unterstützen [YJIT](https://docs.ruby-lang.org/en/master/jit/yjit_md.html), einen leichten, minimalistischen Ruby-JIT-Compiler. YJIT bietet eine deutlich höhere Leistung, benötigt aber auch mehr Speicher als der Ruby-Interpreter. YJIT wird für Ruby-on-Rails-Workloads empfohlen.
YJIT ist standardmäßig nicht aktiviert. Um YJIT für eine Ruby-Funktion zu aktivieren, setzen Sie die Umgebungsvariable auf. `RUBY_YJIT_ENABLE` `1` Um sicherzustellen, dass YJIT aktiviert ist, drucken Sie das Ergebnis der `RubyVM::YJIT.enabled?`-Methode aus.
**Example – Sicherstellen, dass YJIT aktiviert ist**
```
puts(RubyVM::YJIT.enabled?())
# => true
```
# Definieren des Lambda-Funktions-Handlers in Ruby
Der Lambda-Funktions*handler* ist die Methode in Ihrem Funktionscode, die Ereignisse verarbeitet. Wenn Ihre Funktion aufgerufen wird, führt Lambda die Handler-Methode aus. Ihre Funktion wird so lange ausgeführt, bis der Handler eine Antwort zurückgibt, beendet wird oder ein Timeout auftritt.
**Topics**
+ [Ruby-Handler-Grundlagen](#ruby-handler-basics)
+ [Bewährte Codemethoden für Ruby-Lambda-Funktionen](#ruby-best-practices)
## Ruby-Handler-Grundlagen
Im folgenden Beispiel definiert die Datei `function.rb` eine Handler-Methode mit dem Namen `handler`. Die Handler-Funktion nimmt zwei Objekten als Eingabe und gibt ein JSON-Dokument zurück.
**Example function.rb**
```
require 'json'
def handler(event:, context:)
{ event: JSON.generate(event), context: JSON.generate(context.inspect) }
end
```
In Ihrer Funktionskonfiguration gibt die Einstellung `handler` Lambda die Stelle an, an der sich der Handler befindet. Im vorherigen Beispiel ist der korrekte Wert für diese Einstellung **function.handler**. Er enthält zwei Namen, die durch einen Punkt getrennt werden: den Namen der Datei und den Namen der Handler-Methode.
Sie können Ihre Handler-Methode außerdem in einer Klasse definieren. Das folgende Beispiel definiert eine Handler-Methode mit dem Namen `process` in einer Klasse mit dem Namen `Handler` in einem Modul mit dem Namen `LambdaFunctions`.
**Example source.rb**
```
module LambdaFunctions
class Handler
def self.process(event:,context:)
"Hello!"
end
end
end
```
In diesem Fall ist die Handler-Einstellung **source.LambdaFunctions::Handler.process**.
Die zwei Objekte, die der Handler akzeptiert, sind das Aufrufereignis und Context. Das Ereignis ist ein Ruby-Objekt, das die vom Aufrufer bereitgestellte Nutzlast enthält. Wenn es sich bei der Nutzlast um ein JSON-Dokument handelt, ist das Ereignisobjekt ein Ruby-Hash. Andernfalls ist es eine Zeichenfolge. Das [Context-Objekt](ruby-context.md) besitzt Methoden und Eigenschaften, die Informationen zum Aufruf, zur Funktion und zur Ausführungsumgebung bereitstellen.
Der Funktions-Handler wird jedes Mal ausgeführt, wenn Ihre Lambda-Funktion aufgerufen wird. Statischer Code außerhalb des Handler wird einmal pro Funktions-Instance ausgeführt. Wenn Ihr Handler Ressourcen wie SDK-Clients und Datenbankverbindungen verwendet, können Sie diese außerhalb der Handler-Methode erstellen, um sie für mehrere Aufrufe wiederzuverwenden.
Jede Instance Ihrer Funktion kann zwar mehrere Aufrufereignisse verarbeiten, verarbeitet jedoch jeweils nur ein Ereignis zur gleichen Zeit. Die Anzahl der Instances, die zu einem bestimmten Zeitpunkt ein Ereignis verarbeiten, ist die *Nebenläufigkeit* Ihrer Funktion. Weitere Informationen zur Lambda-Ausführungsumgebung finden Sie unter [Verständnis des Lebenszyklus der Lambda-Ausführungsumgebung](lambda-runtime-environment.md).
## Bewährte Codemethoden für Ruby-Lambda-Funktionen
Halten Sie sich an die Richtlinien in der folgenden Liste, um beim Erstellen Ihrer Lambda-Funktionen die besten Codierungspraktiken anzuwenden:
+ **Trennen Sie den Lambda-Handler von Ihrer Core-Logik.** Auf diese Weise können Sie eine Funktion zur besseren Prüfbarkeit von Einheiten schaffen. In Ruby kann dies beispielsweise wie folgt aussehen:
```
def lambda_handler(event:, context:)
foo = event['foo']
bar = event['bar']
result = my_lambda_function(foo:, bar:)
end
def my_lambda_function(foo:, bar:)
// MyLambdaFunction logic here
end
```
+ **Kontrollieren Sie die Abhängigkeiten im Bereitstellungspaket Ihrer Funktion. ** Die AWS Lambda-Ausführungsumgebung enthält eine Reihe von Bibliotheken. Für die Ruby-Laufzeit gehört dazu das AWS-SDK. Um die neuesten Funktionen und Sicherheitsupdates zu aktivieren, wird Lambda diese Bibliotheken regelmäßig aktualisieren. Diese Updates können das Verhalten Ihrer Lambda-Funktion geringfügig verändern. Um die Abhängigkeiten, die Ihre Funktion verwendet, vollständig zu kontrollieren, empfehlen wir, alle Abhängigkeiten mit Ihrem Bereitstellungspaket zu bündeln.
+ **Minimieren Sie die Komplexität Ihrer Abhängigkeiten.** Ziehen Sie einfachere Frameworks vor, die sich schnell beim Start der [Ausführungsumgebung](lambda-runtime-environment.md) laden lassen.
+ **Minimieren Sie die Größe Ihres Bereitstellungspakets auf die für die Laufzeit erforderliche Größe. ** Dadurch verkürzt sich die Zeit, die für das Herunterladen und Entpacken Ihres Bereitstellungspakets vor dem Aufruf benötigt wird. Für Funktionen, die in Ruby erstellt wurden, sollten Sie das Hochladen der gesamten AWS-SDK-Bibliothek als Teil Ihres Bereitstellungspakets vermeiden. Hängen Sie stattdessen selektiv von den Gems ab, die Komponenten des von Ihnen benötigten SDK aufnehmen (z. B. die DynamoDB- oder Amazon S3-SDK-Gems).
**Nutzen Sie die Wiederverwendung der Ausführungsumgebung zur Verbesserung Ihrer Funktion.** Initialisieren Sie SDK-Clients und Datenbankverbindungen außerhalb des Funktions-Handlers und speichern Sie statische Komponenten lokal im `/tmp`-Verzeichnis. Nachfolgende Aufrufe, die von derselben Instance Ihrer Funktion verarbeitet werden, können diese Ressourcen wiederverwenden. Dies spart Kosten durch Reduzierung der Funktionslaufzeit.
Um potenzielle Datenlecks über Aufrufe hinweg zu vermeiden, verwenden Sie die Ausführungsumgebung nicht, um Benutzerdaten, Ereignisse oder andere Informationen mit Sicherheitsauswirkungen zu speichern. Wenn Ihre Funktion auf einem veränderbaren Zustand beruht, der nicht im Speicher innerhalb des Handlers gespeichert werden kann, sollten Sie für jeden Benutzer eine separate Funktion oder separate Versionen einer Funktion erstellen.
**Verwenden Sie eine Keep-Alive-Direktive, um dauerhafte Verbindungen zu pflegen.** Lambda bereinigt Leerlaufverbindungen im Laufe der Zeit. Der Versuch, eine Leerlaufverbindung beim Aufruf einer Funktion wiederzuverwenden, führt zu einem Verbindungsfehler. Um Ihre persistente Verbindung aufrechtzuerhalten, verwenden Sie die Keep-Alive-Direktive, die Ihrer Laufzeit zugeordnet ist. Ein Beispiel finden Sie unter [Wiederverwenden von Verbindungen mit Keep-Alive in Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).
**Verwenden Sie [Umgebungsvariablen](configuration-envvars.md) um Betriebsparameter an Ihre Funktion zu übergeben.** Wenn Sie z. B. Daten in einen Amazon-S3-Bucket schreiben, anstatt den Bucket-Namen, in den Sie schreiben, hartzucodieren, konfigurieren Sie den Bucket-Namen als Umgebungsvariable.
**Vermeiden Sie rekursive Aufrufe** in Ihrer Lambda-Funktion, bei denen die Funktion sich selbst aufruft oder einen Prozess initiiert, der die Funktion erneut aufrufen kann. Dies kann zu unvorhergesehenen Mengen an Funktionsaufrufen führen und höhere Kosten zur Folge haben. Wenn Sie eine unbeabsichtigte Menge von Aufrufen feststellen, legen Sie die reservierte gleichzeitige Ausführung der Funktion auf `0` fest, um sofort alle Aufrufe der Funktion zu drosseln, während Sie den Code aktualisieren.
**Verwenden Sie keine nicht dokumentierten, nicht öffentlichen APIs** in Ihrem Lambda-Funktionscode. Für AWS Lambda-verwaltete Laufzeiten wendet Lambda regelmäßig Sicherheits- und Funktionsupdates auf Lambdas interne APIs an. Diese internen API-Updates können abwärtskompatibel sein, was zu unbeabsichtigten Konsequenzen wie Aufruffehlern führt, wenn Ihre Funktion von diesen nicht öffentlichen APIs abhängig ist. Eine Liste öffentlich zugänglicher APIs finden Sie in der [API-Referenz](https://docs.aws.amazon.com/lambda/latest/api/welcome.html).
**Schreiben Sie idempotenten Code.** Das Schreiben idempotenter Code für Ihre Funktionen stellt sicher, dass doppelte Ereignisse auf die gleiche Weise behandelt werden. Ihr Code sollte Ereignisse ordnungsgemäß validieren und doppelte Ereignisse ordnungsgemäß behandeln. Weitere Informationen finden Sie unter [Wie mache ich meine Lambda-Funktion idempotent?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).
# Bereitstellen von Ruby-Lambda-Funktionen mit ZIP-Dateiarchiven
Der Code Ihrer AWS Lambda-Funktion besteht aus einer RB-Datei, die den Handler-Code Ihrer Funktion sowie sämtliche zusätzliche Abhängigkeiten (Gems) enthält, von denen Ihr Code ggf. abhängt. Sie verwenden ein *Bereitstellungspaket*, um Ihren Funktionscode in Lambda bereitzustellen. Dieses Paket kann entweder ein ZIP-Dateiarchiv oder ein Container-Image sein. Weitere Informationen zur Verwendung von Container-Images mit Ruby finden Sie unter [Bereitstellen von Ruby-Lambda-Funktionen mit Container-Images](https://docs.aws.amazon.com/lambda/latest/dg/ruby-image.html).
Zum Erstellen des Bereitstellungspakets für ein ZIP-Dateiarchiv können Sie ein integriertes Dienstprogramm für ZIP-Dateien Ihres Befehlszeilen-Tools oder ein anderes Dienstprogramm für ZIP-Dateien verwenden, wie [7zip](https://www.7-zip.org/download.html). In den Beispiele in den folgenden Abschnitten wird davon ausgegangen, dass Sie ein `zip`-Befehlszeilen-Tool in einer Linux- oder MacOS-Umgebung verwenden. Unter Windows können Sie das [Windows-Subsystem für Linux installieren](https://docs.microsoft.com/en-us/windows/wsl/install-win10), um eine Windows-Version von Ubuntu und Bash zu erhalten und dieselben Befehle zu verwenden.
Da Lambda POSIX-Dateiberechtigungen verwendet, müssen Sie möglicherweise [Berechtigungen für den Bereitstellungspaketordner festlegen](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/), bevor Sie das ZIP-Dateiarchiv erstellen.
In den Beispielbefehlen in den folgenden Abschnitten wird das Hilfsprogramm [Bundler](https://bundler.io/) verwendet, um Ihrem Bereitstellungspaket Abhängigkeiten hinzuzufügen. Führen Sie zum Installieren von Bundler den folgenden Befehl aus:
```
gem install bundler
```
**Topics**
+ [Abhängigkeiten in Ruby](#ruby-package-runtime-dependencies)
+ [ZIP-Bereitstellungspakets ohne Abhängigkeiten erstellen](#ruby-package-codeonly)
+ [ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen](#ruby-package-dependencies)
+ [Erstellen einer Ruby-Ebene für Ihre Abhängigkeiten](#ruby-package-dependencies-layers)
+ [Erstellen von ZIP-Bereitstellungspaketen mit nativen Bibliotheken](#ruby-package-native)
+ [Erstellen und Aktualisieren von Ruby-Lambda-Funktionen mithilfe von ZIP-Dateien](#ruby-package-create-functions)
## Abhängigkeiten in Ruby
Bei Lambda-Funktionen, die die Ruby-Laufzeit verwenden, kann eine Abhängigkeit ein beliebiges Ruby-Gem sein. Bei Bereitstellung Ihrer Funktion mithilfe eines ZIP-Archivs können Sie diese Abhängigkeiten entweder mit Ihrem Funktionscode zu Ihrer ZIP-Datei hinzufügen oder eine Lambda-Ebene verwenden. Eine Ebene ist ein separates ZIP-Dateiarchiv, das zusätzlichen Code und andere Daten enthalten kann. Weitere Informationen zur Verwendung von Lambda-Ebenen finden Sie unter [Verwaltung von Lambda-Abhängigkeiten mit Ebenen](chapter-layers.md).
Die Ruby-Laufzeit beinhaltet die AWS SDK für Ruby. Wenn Ihre Funktion das SDK verwendet, müssen Sie es nicht mit Ihrem Code bündeln. Wenn Sie jedoch die volle Kontrolle über Ihre Abhängigkeiten behalten oder eine bestimmte Version des SDK verwenden möchten, können Sie es dem Bereitstellungspaket Ihrer Funktion hinzufügen. Sie können das SDK entweder in Ihre ZIP-Datei aufnehmen oder es mithilfe einer Lambda-Ebene hinzufügen. Abhängigkeiten in Ihrer ZIP-Datei oder auf Lambda-Ebenen haben Vorrang vor Versionen, die in der Laufzeit enthalten sind. Welche Version des SDK für Ruby in Ihrer Laufzeitversion enthalten ist, erfahren Sie unter [SDK-Versionen, die zur Laufzeit enthalten sind](lambda-ruby.md#ruby-sdk-included).
Im Rahmen des [AWS-Modells der geteilten Verantwortung](lambda-runtimes.md#runtimes-shared-responsibility) sind Sie für die Verwaltung aller Abhängigkeiten in den Bereitstellungspaketen Ihrer Funktionen verantwortlich. Dies beinhaltet das Durchführen von Updates und Sicherheitspatches. Zum Aktualisieren von Abhängigkeiten im Bereitstellungspaket Ihrer Funktion erstellen Sie zunächst eine neue ZIP-Datei und laden Sie diese dann in Lambda hoch. Weitere Informationen finden Sie unter [ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen](#ruby-package-dependencies) und [Erstellen und Aktualisieren von Ruby-Lambda-Funktionen mithilfe von ZIP-Dateien](#ruby-package-create-functions).
## ZIP-Bereitstellungspakets ohne Abhängigkeiten erstellen
Hat Ihr Funktionscode keine Abhängigkeiten, enthält Ihre ZIP-Datei nur die RB-Datei mit dem Handler-Code Ihrer Funktion. Erstellen Sie mit Ihrem bevorzugten ZIP-Programm eine ZIP-Datei mit Ihrer RB-Datei im Stammverzeichnis. Befindet sich die RB-Datei nicht im Stammverzeichnis Ihrer ZIP-Datei, kann Lambda Ihren Code nicht ausführen.
Informationen zum Bereitstellen Ihrer ZIP-Datei zum Erstellen einer neuen Lambda-Funktion oder Aktualisieren einer vorhandenen Funktion, finden Sie unter [Erstellen und Aktualisieren von Ruby-Lambda-Funktionen mithilfe von ZIP-Dateien](#ruby-package-create-functions).
## ZIP-Bereitstellungspakets mit Abhängigkeiten erstellen
Hängt Ihr Funktionscode von zusätzlichen Ruby-Gems ab, können Sie diese Abhängigkeiten entweder mit Ihrem Funktionscode in Ihre ZIP-Datei aufnehmen oder eine [Lambda-Ebene](chapter-layers.md) verwenden. In diesem Abschnitt erfahren Sie, wie Sie Ihre Abhängigkeiten in Ihr ZIP-Bereitstellungspaket aufnehmen. Anweisungen zum Einschließen Ihrer Abhängigkeiten in eine Ebene finden Sie unter [Erstellen einer Ruby-Ebene für Ihre Abhängigkeiten](#ruby-package-dependencies-layers).
Angenommen, Ihr Funktionscode ist in einer Datei mit dem Namen `lambda_function.rb` in Ihrem Projektverzeichnis gespeichert. Die folgenden CLI-Befehle erstellen Sie eine ZIP-Datei mit dem Namen „`my_deployment_package.zip`“, die Ihren Funktionscode und seine Abhängigkeiten enthält.
**Erstellen des Bereitstellungspakets**
1. Erstellen Sie in Ihrem Projektverzeichnis eine `Gemfile`-Datei für die Angabe Ihrer Abhängigkeiten.
```
bundle init
```
1. Bearbeiten Sie die `Gemfile`-Datei mit Ihrem bevorzugten Texteditor, um die Abhängigkeiten Ihrer Funktion anzugeben. Wenn Sie also beispielsweise das TZInfo-Gem verwenden möchten, bearbeiten Sie Ihre `Gemfile`-Datei so, dass sie wie folgt aussieht:
```
source "https://rubygems.org"
gem "tzinfo"
```
1. Führen Sie den folgenden Befehl aus, um die in Ihrer `Gemfile`-Datei angegebenen Gems in Ihrem Projektverzeichnis zu installieren. Durch diesen Befehl wird `vendor/bundle` als Standardpfad für Gem-Installationen festgelegt:
```
bundle config set --local path 'vendor/bundle' && bundle install
```
Die Ausgabe sollte in etwa wie folgt aussehen:
```
Fetching gem metadata from https://rubygems.org/...........
Resolving dependencies...
Using bundler 2.4.13
Fetching tzinfo 2.0.6
Installing tzinfo 2.0.6
...
```
**Anmerkung**
Wenn Sie Gems später wieder global installieren möchten, können Sie den folgenden Befehl ausführen:
```
bundle config set --local system 'true'
```
1. Erstellen Sie ein ZIP-Dateiarchiv, das die `lambda_function.rb`-Datei mit dem Handler-Code Ihrer Funktion sowie mit den Abhängigkeiten enthält, die Sie im vorherigen Schritt installiert haben.
```
zip -r my_deployment_package.zip lambda_function.rb vendor
```
Die Ausgabe sollte in etwa wie folgt aussehen:
```
adding: lambda_function.rb (deflated 37%)
adding: vendor/ (stored 0%)
adding: vendor/bundle/ (stored 0%)
adding: vendor/bundle/ruby/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/build_info/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/cache/ (stored 0%)
adding: vendor/bundle/ruby/3.2.0/cache/aws-eventstream-1.0.1.gem (deflated 36%)
...
```
## Erstellen einer Ruby-Ebene für Ihre Abhängigkeiten
Informationen zum Verpacken Ihrer Ruby-Abhängigkeiten in eine Lambda-Ebene finden Sie unter [Arbeiten mit Ebenen für Ruby Lambda-Funktionen](ruby-layers.md).
## Erstellen von ZIP-Bereitstellungspaketen mit nativen Bibliotheken
Viele gängige Ruby-Gems wie `nokogiri`, `nio4r` und `mysql` enthalten native, in C geschriebene Erweiterungen. Wenn Sie Ihrem Bereitstellungspaket Bibliotheken hinzufügen, die C-Code enthalten, müssen Sie Ihr Paket korrekt erstellen, damit es mit der Lambda-Ausführungsumgebung kompatibel ist.
Bei Produktionsanwendungen empfiehlt es sich, Ihren Code mit dem AWS Serverless Application Model (AWS SAM) zu erstellen und bereitzustellen. Verwenden Sie in AWS SAM die Option `sam build --use-container`, um Ihre Funktion in einem Lambda-ähnlichen Docker-Container zu erstellen. Weitere Informationen zur Bereitstellung Ihres Funktionscodes mithilfe von AWS SAM finden Sie im *AWS SAM-Entwicklerhandbuch* unter [Building applications](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-using-build.html).
Wenn Sie ein ZIP-Bereitstellungspaket, das Gems mit nativen Erweiterungen enthält, ohne Verwendung von AWS SAM erstellen möchten, können Sie Ihre Abhängigkeiten alternativ mithilfe eines Containers in einer Umgebung bündeln, die mit der Lambda-Ruby-Laufzeitumgebung identisch ist. Für diese Schritte muss Docker auf Ihrem Build-Computer installiert sein. Weitere Informationen zur Installation von Docker finden Sie unter [Install Docker Engine](https://docs.docker.com/engine/install/).
**So erstellen Sie ein ZIP-Bereitstellungspaket in einem Docker-Container**
1. Erstellen Sie auf Ihrem lokalen Build-Computer einen Ordner als Speicherort für Ihren Container. Erstellen Sie in diesem Ordner eine Datei mit dem Namen `dockerfile` und fügen Sie folgenden Code in die Datei ein:
```
FROM public.ecr.aws/sam/build-ruby3.2:latest-x86_64
RUN gem update bundler
CMD "/bin/bash"
```
1. Führen Sie in dem Ordner, in dem Sie Ihre `dockerfile`-Datei erstellt haben, den folgenden Befehl aus, um den Docker-Container zu erstellen:
```
docker build -t awsruby32 .
```
1. Navigieren Sie zu dem Projektverzeichnis, das die Datei vom Typ `.rb` mit dem Handler-Code Ihrer Funktion sowie die `Gemfile`-Datei mit den Abhängigkeiten Ihrer enthält. Führen Sie in diesem Verzeichnis den folgenden Befehl aus, um den Lambda-Ruby-Container zu starten:
------
#### [ Linux/MacOS ]
```
docker run --rm -it -v $PWD:/var/task -w /var/task awsruby32
```
**Anmerkung**
In macOS wird möglicherweise eine Warnung mit dem Hinweis angezeigt, dass die Plattform des angeforderten Images nicht der erkannten Hostplattform entspricht. Ignorieren Sie diese Warnung.
------
#### [ Windows PowerShell ]
```
docker run --rm -it -v ${pwd}:var/task -w /var/task awsruby32
```
------
Wenn Ihr Container startet, sollte eine Bash-Aufforderung angezeigt werden.
```
bash-4.2#
```
1. Konfigurieren Sie das Hilfsprogramm „bundle“, um die in Ihrer `Gemfile`-Datei angegebenen Gems in einem lokalen Verzeichnis namens `vendor/bundle` zu installieren und Ihre Abhängigkeiten zu installieren.
```
bash-4.2# bundle config set --local path 'vendor/bundle' && bundle install
```
1. Erstellen Sie das ZIP-Bereitstellungspaket mit Ihrem Funktionscode und den zugehörigen Abhängigkeiten. In diesem Beispiel hat die Datei, die den Handler-Code Ihrer Funktion enthält, den Namen `lambda_function.rb`.
```
bash-4.2# zip -r my_deployment_package.zip lambda_function.rb vendor
```
1. Verlassen Sie den Container und kehren Sie zu Ihrem lokalen Projektverzeichnis zurück.
```
bash-4.2# exit
```
Nun können Sie Ihre Lambda-Funktion mithilfe des ZIP-Bereitstellungspakets erstellen oder aktualisieren. Siehe [Erstellen und Aktualisieren von Ruby-Lambda-Funktionen mithilfe von ZIP-Dateien](#ruby-package-create-functions)
## Erstellen und Aktualisieren von Ruby-Lambda-Funktionen mithilfe von ZIP-Dateien
Nach der Erstellung Ihres ZIP-Bereitstellungspakets können Sie es verwenden, um eine neue Lambda-Funktion zu erstellen oder eine vorhandene zu aktualisieren. Ihr ZIP-Bereitstellungspaket lässt sich über die Lambda-Konsole, das AWS Command Line Interface und die Lambda-API hochladen. Sie können Lambda-Funktionen auch mit AWS Serverless Application Model (AWS SAM) und CloudFormation erstellen und aktualisieren.
Die maximale Größe eines ZIP-Bereitstellungspakets für Lambda beträgt 250 MB (entpackt). Beachten Sie, dass dieser Grenzwert für die kombinierte Größe aller hochgeladenen Dateien gilt, einschließlich aller Lambda-Ebenen.
Die Lambda-Laufzeit benötigt die Berechtigung zum Lesen der Dateien in Ihrem Bereitstellungspaket. In der oktalen Linux-Notation der Berechtigungen benötigt Lambda 644 Berechtigungen für nicht ausführbare Dateien (rw-r--r--) und 755 Berechtigungen (rwxr-xr-x) für Verzeichnisse und ausführbare Dateien.
Verwenden Sie unter Linux und MacOS den `chmod`-Befehl, um Dateiberechtigungen für Dateien und Verzeichnisse in Ihrem Bereitstellungspaket zu ändern. Um beispielsweise einer nicht ausführbaren Datei die richtigen Berechtigungen zu geben, führen Sie den folgenden Befehl aus.
```
chmod 644
```
Informationen zum Ändern von Dateiberechtigungen in Windows finden Sie unter [Festlegen, Anzeigen, Ändern oder Entfernen von Berechtigungen für ein Objekt](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) in der Microsoft-Windows-Dokumentation.
**Anmerkung**
Wenn Sie Lambda nicht die Berechtigungen gewähren, die es für den Zugriff auf Verzeichnisse in Ihrem Bereitstellungspaket benötigt, setzt Lambda die Berechtigungen für diese Verzeichnisse auf 755 (rwxr-xr-x).
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien unter Verwendung der Konsole
Eine neue Funktion müssen Sie zuerst in der Konsole erstellen und dann Ihr ZIP-Archiv hochladen. Zum Aktualisieren einer bestehenden Funktion öffnen Sie die Seite für Ihre Funktion und gehen dann genauso vor, um Ihre aktualisierte ZIP-Datei hinzuzufügen.
Bei einer ZIP-Datei mit unter 50 MB können Sie eine Funktion erstellen oder aktualisieren, indem Sie die Datei direkt von Ihrem lokalen Computer hochladen. Bei ZIP-Dateien mit einer Größe von mehr als 50 MB müssen Sie Ihr Paket zuerst in einen Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon-S3-Bucket unter Verwendung der AWS-Managementkonsole finden Sie unter [Erste Schritte mit Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). Informationen zum Hochladen von Dateien mit der AWS CLI finden Sie im *AWS CLI-Benutzerhandbuch* unter [Verschieben von Objekten](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move).
**Anmerkung**
Sie können den [Bereitstellungspakettyp](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip oder Container-Image) für eine vorhandene Funktion nicht ändern. Sie können zum Beispiel eine Container-Image-Funktion nicht so umwandeln, dass sie ein .zip-Archiv verwendet. Sie müssen eine neue Funktion erstellen.
**So erstellen Sie eine neue Funktion (Konsole)**
1. Öffnen Sie die [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie **Funktion erstellen** aus.
1. Wählen Sie **Author from scratch** aus.
1. Führen Sie unter **Basic information** (Grundlegende Informationen) die folgenden Schritte aus:
1. Geben Sie als **Funktionsname** den Namen Ihrer Funktion ein.
1. Wählen Sie für **Laufzeit** die Laufzeit aus, die Sie verwenden möchten.
1. (Optional) Für **Architektur** wählen Sie die Befehlssatz-Architektur für Ihre Funktion aus. Die Standardarchitektur ist x86\$164. Stellen Sie sicher, dass das ZIP-Bereitstellungspaket für Ihre Funktion mit der von Ihnen gewählten Befehlssatzarchitektur kompatibel ist.
1. (Optional) Erweitern Sie unter **Berechtigungen** die Option **Standardausführungsrolle ändern**. Sie können eine neue **Ausführungsrolle** erstellen oder eine vorhandene Rolle verwenden.
1. Wählen Sie **Funktion erstellen**. Lambda erstellt eine grundlegende „Hello World“-Funktion mit der von Ihnen gewählten Laufzeit.
**So laden Sie ein ZIP-Archiv von Ihrem lokalen Computer hoch (Konsole)**
1. Wählen Sie auf der [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole die Funktion aus, für die Sie die ZIP-Datei hochladen möchten.
1. Wählen Sie die Registerkarte **Code** aus.
1. Wählen Sie im Bereich **Codequelle** die Option **Hochladen von** aus.
1. Wählen Sie die **ZIP-Datei** aus.
1. Laden Sie die ZIP-Datei wie folgt hoch:
1. Wählen Sie **Hochladen** und dann Ihre ZIP-Datei in der Dateiauswahl aus.
1. Klicken Sie auf **Open**.
1. Wählen Sie **Speichern**.
**So laden Sie ein ZIP-Archiv aus einem Amazon-S3-Bucket hoch (Konsole)**
1. Wählen Sie auf der [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole die Funktion aus, für die Sie eine neue ZIP-Datei hochladen möchten.
1. Wählen Sie die Registerkarte **Code** aus.
1. Wählen Sie im Bereich **Codequelle** die Option **Hochladen von** aus.
1. Wählen Sie den **Amazon-S3-Speicherort** aus.
1. Fügen Sie die Amazon-S3-Link-URL Ihrer ZIP-Datei ein und wählen Sie **Speichern** aus.
### ZIP-Dateifunktionen mithilfe des Konsolencode-Editors aktualisieren
Für einige Funktionen mit ZIP-Bereitstellungspaketen können Sie Ihren Funktionscode direkt mit dem in der Lambda-Konsole integrierten Code-Editor aktualisieren. Zur Verwendung dieses Features muss Ihre Funktion folgende Kriterien erfüllen:
+ Ihre Funktion muss eine der interpretierten Sprache der Laufzeit verwenden (Python, Node.js oder Ruby).
+ Das Bereitstellungspaket Ihrer Funktion muss kleiner als 50 MB (entpackt) sein.
Funktionscode für Funktionen mit Container-Image-Bereitstellungspaketen kann nicht direkt in der Konsole bearbeitet werden.
**So aktualiseren Sie Ihren Funktionscode mit dem Code-Editor**
1. Öffnen Sie die [Funktionsseite](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole und wählen Sie Ihre Funktion aus.
1. Wählen Sie die Registerkarte **Code** aus.
1. Wählen Sie im Bereich **Codequelle** Ihre Quellcodedatei aus und bearbeiten Sie sie im integrierten Code-Editor.
1. Wählen Sie im Abschnitt **BEREITSTELLEN** die Option **Bereitstellen** aus, um den Code Ihrer Funktion zu aktualisieren:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien unter Verwendung der AWS CLI
Sie können die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) verwenden, um eine neue Funktion zu erstellen oder eine vorhandene unter Verwendung einer ZIP-Datei zu aktualisieren. Verwenden Sie die Befehle [Funktion erstellen](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) und [Funktionscode aktualisieren](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html), um Ihr ZIP-Paket bereitzustellen. Wenn Ihre ZIP-Datei kleiner als 50 MB ist, können Sie das ZIP-Paket von einem Dateispeicherort auf Ihrem lokalen Build-Computer hochladen. Bei größeren Dateien müssen Sie Ihr ZIP-Paket aus einem Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon-S3-Bucket unter Verwendung der AWS CLI finden Sie unter [Verschieben von Objekten](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI-Benutzerhandbuch*.
**Anmerkung**
Wenn Sie Ihre ZIP-Datei unter Verwendung der AWS CLI aus einem Amazon-S3-Bucket hochladen, muss sich der Bucket in der gleichen AWS-Region wie Ihre Funktion befinden.
Um eine neue Funktion unter Verwendung einer ZIP-Datei mit der AWS CLI zu erstellen, müssen Sie Folgendes angeben:
+ Den Namen Ihrer Funktion (`--function-name`)
+ Die Laufzeit Ihrer Funktion (`--runtime`)
+ Den Amazon-Ressourcennamen (ARN) der [Ausführungsrolle](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) der Funktion (`--role`).
+ Den Namen der Handler-Methode in Ihrem Funktionscode (`--handler`)
Sie müssen auch den Speicherort Ihrer ZIP-Datei angeben. Befindet sich Ihre ZIP-Datei in einem Ordner auf Ihrem lokalen Build-Computer, verwenden Sie die `--zip-file`-Option, um den Dateipfad anzugeben, wie im folgenden Beispielbefehl gezeigt.
```
aws lambda create-function --function-name myFunction \
--runtime ruby3.2 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Zur Angabe des Speicherorts der ZIP-Datei in einem Amazon-S3-Bucket verwenden Sie die im folgenden Beispielbefehl gezeigte `--code`-Option. Sie müssen den `S3ObjectVersion`-Parameter nur für versionierte Objekte verwenden.
```
aws lambda create-function --function-name myFunction \
--runtime ruby3.2 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
Um eine vorhandene Funktion mit der CLI zu aktualisieren, geben Sie den Namen Ihrer Funktion unter Verwendung des `--function-name`-Parameters an. Sie müssen auch den Speicherort der ZIP-Datei angeben, die Sie zum Aktualisieren Ihres Funktionscodes verwenden möchten. Befindet sich Ihre ZIP-Datei in einem Ordner auf Ihrem lokalen Build-Computer, verwenden Sie die `--zip-file`-Option, um den Dateipfad anzugeben, wie im folgenden Beispielbefehl gezeigt.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Zur Angabe des Speicherorts der ZIP-Datei in einem Amazon-S3-Bucket verwenden Sie die im folgenden Beispielbefehl gezeigten `--s3-bucket`- und `--s3-key`-Optionen. Sie müssen den `--s3-object-version`-Parameter nur für versionierte Objekte verwenden.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien unter Verwendung der Lambda-API
Um Funktionen zu erstellen und zu konfigurieren, die ein ZIP-Dateiarchiv verwenden, verwenden Sie die folgenden API-Operationen:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien unter Verwendung von AWS SAM
Das AWS Serverless Application Model (AWS SAM) ist ein Toolkit, das den Prozess der Erstellung und Ausführung von Serverless-Anwendungen auf AWS optimiert. Sie definieren die Ressourcen für Ihre Anwendung in einer YAML- oder JSON-Vorlage und verwenden die AWS SAM-Befehlszeilenschnittstelle (AWS SAM CLI), um Ihre Anwendungen zu erstellen, zu verpacken und bereitzustellen. Wenn Sie eine Lambda-Funktion aus einer AWS SAM-Vorlage erstellen, erstellt AWS SAM automatisch ein ZIP-Bereitstellungspaket oder ein Container-Image mit Ihrem Funktionscode und allen von Ihnen angegebenen Abhängigkeiten. Weitere Informationen zur Verwendung von AWS SAM für die Erstellung und Bereitstellung von Lambda-Funktionen finden Sie unter [Erste Schritte mit AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) im *AWS Serverless Application Model-Entwicklerhandbuch*.
Sie können außerdem AWS SAM verwenden, um eine Lambda-Funktion unter Verwendung eines vorhandenen ZIP-Dateiarchivs zu erstellen. Um eine Lambda-Funktion unter Verwendung von AWS SAM zu erstellen, können Sie Ihre ZIP-Datei in einem Amazon-S3-Bucket oder in einem lokalen Ordner auf Ihrem Build-Computer speichern. Anweisungen zum Hochladen einer Datei in einen Amazon-S3-Bucket unter Verwendung der AWS CLI finden Sie unter [Verschieben von Objekten](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI-Benutzerhandbuch*.
In Ihrer AWS SAM-Vorlage gibt die `AWS::Serverless::Function`-Ressource Ihre Lambda-Funktion an. Legen Sie in dieser Ressource die folgenden Eigenschaften fest, um eine Funktion zu erstellen, die als ZIP-Datei-Archiv definiert ist:
+ `PackageType` – festlegen auf `Zip`
+ `CodeUri` – festlegen auf die Amazon-S3-URI, den Pfad zum lokalen Ordner oder das [Funktionscode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)-Objekt
+ `Runtime` – festlegen auf die gewünschte Laufzeit
Mit AWS SAM müssen Sie Ihre ZIP-Datei nicht zuerst in einen Amazon-S3-Bucket hochladen, auch wenn sie größer als 50 MB ist. AWS SAM kann ZIP-Pakete bis zur maximal zulässigen Dateigröße von 250 MB (entpackt) von einem Speicherort auf Ihrem lokalen Build-Computer hochladen.
Weitere Informationen zur Bereitstellung von Funktionen mit einer ZIP-Datei in AWS SAM finden Sie unter [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) im *AWS SAM-Entwicklerhandbuch*.
### Erstellen und Aktualisieren von Funktionen mit ZIP-Dateien unter Verwendung von CloudFormation
Sie können CloudFormation verwenden, um eine Lambda-Funktion unter Verwendung eines ZIP-Dateiarchivs zu erstellen. Um eine Lambda-Funktion aus einer ZIP-Datei zu erstellen, müssen Sie Ihre Datei zunächst in einen Amazon-S3-Bucket hochladen. Anweisungen zum Hochladen einer Datei in einen Amazon-S3-Bucket unter Verwendung der AWS CLI finden Sie unter [Verschieben von Objekten](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) im *AWS CLI-Benutzerhandbuch*.
In Ihrer CloudFormation-Vorlage gibt die `AWS::Lambda::Function`-Ressource Ihre Lambda-Funktion an. Legen Sie in dieser Ressource die folgenden Eigenschaften fest, um eine Funktion zu erstellen, die als ZIP-Datei-Archiv definiert ist:
+ `PackageType` – festlegen auf `Zip`
+ `Code` – Geben Sie den Namen des Amazon-S3-Buckets und den ZIP-Dateinamen in die Felder `S3Bucket` und `S3Key` ein
+ `Runtime` – festlegen auf die gewünschte Laufzeit
Die von CloudFormation generierte ZIP-Datei darf nicht größer als 4 MB sein. Weitere Informationen zur Bereitstellung von Funktionen mit einer ZIP-Datei in CloudFormation finden Sie unter [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html) im *CloudFormation-Entwicklerhandbuch*.
# Bereitstellen von Ruby-Lambda-Funktionen mit Container-Images
Es gibt drei Möglichkeiten, ein Container-Image für eine Ruby-Lambda-Funktion zu erstellen:
+ [Verwenden eines AWS Basis-Images für Ruby](#ruby-image-instructions)
Die [AWS -Basis-Images](images-create.md#runtimes-images-lp) sind mit einer Sprachlaufzeit, einem Laufzeitschnittstellen-Client zur Verwaltung der Interaktion zwischen Lambda und Ihrem Funktionscode und einem Laufzeitschnittstellen-Emulator für lokale Tests vorinstalliert.
+ [Es wird ein AWS reines Betriebssystem-Basis-Image verwendet](images-create.md#runtimes-images-provided)
[AWS Basis-Images nur für Betriebssysteme](https://gallery.ecr.aws/lambda/provided) enthalten eine Amazon Linux-Distribution und den [Runtime-Interface-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Diese Images werden häufig verwendet, um Container-Images für kompilierte Sprachen wie [Go](go-image.md#go-image-provided) und [Rust](lambda-rust.md) sowie für eine Sprache oder Sprachversion zu erstellen, für die Lambda kein Basis-Image bereitstellt, wie Node.js 19. Sie können reine OS-Basis-Images auch verwenden, um eine [benutzerdefinierte Laufzeit](runtimes-custom.md) zu implementieren. Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Laufzeitschnittstellen-Client für Ruby](#ruby-image-clients) in das Image aufnehmen.
+ [Verwenden Sie ein Nicht-Basis-Image AWS ](#ruby-image-clients)
Sie können auch ein alternatives Basis-Image aus einer anderen Container-Registry verwenden. Sie können auch ein von Ihrer Organisation erstelltes benutzerdefiniertes Image verwenden. Um das Image mit Lambda kompatibel zu machen, müssen Sie den [Laufzeitschnittstellen-Client für Ruby](#ruby-image-clients) in das Image aufnehmen.
**Tipp**
Um die Zeit zu reduzieren, die benötigt wird, bis Lambda-Container-Funktionen aktiv werden, siehe die Docker-Dokumentation unter [Verwenden mehrstufiger Builds](https://docs.docker.com/build/building/multi-stage/). Um effiziente Container-Images zu erstellen, folgen Sie den [Bewährte Methoden für das Schreiben von Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Auf dieser Seite wird erklärt, wie Sie Container-Images für Lambda erstellen, testen und bereitstellen.
**Topics**
+ [AWS Basis-Images für Ruby](#ruby-image-base)
+ [Verwenden eines AWS Basis-Images für Ruby](#ruby-image-instructions)
+ [Verwenden eines alternativen Basis-Images mit dem Laufzeitschnittstellen-Client](#ruby-image-clients)
## AWS Basis-Images für Ruby
AWS stellt die folgenden Basis-Images für Ruby bereit:
| Tags (Markierungen) | Laufzeit | Betriebssystem | Dockerfile | Ablehnung |
| --- | --- | --- | --- | --- |
| 3.4 | Ruby 3.4 | Amazon Linux 2023 | [Dockerfile für Ruby 3.4 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.4/Dockerfile.ruby3.4) | 31. März 2028 |
| 3.3 | Ruby 3.3 | Amazon Linux 2023 | [Dockerfile für Ruby 3.3 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.3/Dockerfile.ruby3.3) | 31. März 2027 |
| 3.2 | Ruby 3.2 | Amazon Linux 2 | [Dockerfile für Ruby 3.2 auf GitHub](https://github.com/aws/aws-lambda-base-images/blob/ruby3.2/Dockerfile.ruby3.2) | 31. März 2026 |
Amazon ECR-Repository: [gallery.ecr. aws/lambda/ruby](https://gallery.ecr.aws/lambda/ruby)
## Verwenden eines AWS Basis-Images für Ruby
### Voraussetzungen
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (Mindestversion 25.0.0)
+ Das Docker-[buildx-Plugin](https://github.com/docker/buildx/blob/master/README.md).
+ Ruby
### Erstellen eines Images aus einem Base Image
**Erstellen eines Container-Images für Ruby**
1. Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir example
cd example
```
1. Erstellen Sie eine neue Datei mit dem Namen `Gemfile`. Hier listen Sie die benötigten RubyGems Pakete für Ihre Anwendung auf. Das AWS SDK für Ruby ist erhältlich bei RubyGems. Sie sollten bestimmte AWS Service Gems für die Installation auswählen. Um beispielsweise das [Ruby-Gem für Lambda](https://rubygems.org/gems/aws-sdk-lambda/) zu verwenden, sollte Ihr Gemfile so aussehen:
```
source 'https://rubygems.org'
gem 'aws-sdk-lambda'
```
Alternativ enthält das [aws-sdk-Gem](https://rubygems.org/gems/aws-sdk/) jedes verfügbare AWS Service-Gem. Dieses Gem ist sehr groß. Wir empfehlen, es nur zu verwenden, wenn Sie auf viele AWS Dienste angewiesen sind.
1. Installieren Sie die im Gemfile angegebenen Abhängigkeiten mithilfe von [bundle install](https://bundler.io/v2.4/man/bundle-install.1.html).
```
bundle install
```
1. Erstellen Sie eine neue Datei mit dem Namen `lambda_function.rb`. Sie können der Datei zum Testen den folgenden Beispielfunktionscode hinzufügen oder Ihren eigenen verwenden.
**Example Ruby-Funktion**
```
module LambdaFunction
class Handler
def self.process(event:,context:)
"Hello from Lambda!"
end
end
end
```
1. Erstellen Sie eine neue Docker-Datei. Es folgt ein Beispiel für ein Dockerfile, das ein [AWS -Basis-Image](images-create.md#runtimes-images-lp) verwendet. Dieses Dockerfile verwendet die folgende Konfiguration:
+ Setzen Sie die `FROM`-Eigenschaft auf den URI des Basis-Images.
+ Verwenden Sie den Befehl COPY, um den Funktionscode und die Laufzeitabhängigkeiten in `{LAMBDA_TASK_ROOT}`, eine von [Lambda definierte Umgebungsvariable](configuration-envvars.md#configuration-envvars-runtime) zu kopieren.
+ Legen Sie das `CMD`-Argument auf den Lambda-Funktionshandler fest.
Beachten Sie, dass das Dockerfile-Beispiel keine [USER-Anweisung](https://docs.docker.com/reference/dockerfile/#user) enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der `root`-Benutzer verwendet wird, wenn keine `USER`-Anweisung bereitgestellt wird.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/ruby:3.4
# Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ${LAMBDA_TASK_ROOT}/
# Install Bundler and the specified gems
RUN gem install bundler:2.4.20 && \
bundle config set --local path 'vendor/bundle' && \
bundle install
# Copy function code
COPY lambda_function.rb ${LAMBDA_TASK_ROOT}/
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.LambdaFunction::Handler.process" ]
```
1. Erstellen Sie Ihr Docker-Image mit dem [docker build](https://docs.docker.com/engine/reference/commandline/build/)-Befehl. Das folgende Beispiel benennt das Bild in `docker-image` und gibt ihm den `test` [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die Option `--provenance=false` verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Anmerkung**
Der Befehl gibt die `--platform linux/amd64`-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die `--platform linux/arm64` Option verwendet.
### (Optional) Testen Sie das Image lokal
1. Starten Sie Ihr Docker-Image mit dem **docker run**-Befehl. In diesem Beispiel ist `docker-image` der Image-Name und `test` der Tag.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei `localhost:9000/2015-03-31/functions/function/invocations`.
**Anmerkung**
Wenn Sie das Docker-Image für die ARM64 Befehlssatzarchitektur erstellt haben, stellen Sie sicher, dass Sie stattdessen die `--platform linux/arm64` Option verwenden. `--platform linux/amd64`
1. Veröffentlichen Sie in einem neuen Terminalfenster ein Ereignis an den lokalen Endpunkt.
------
#### [ Linux/macOS ]
Führen Sie unter Linux oder macOS den folgenden `curl`-Befehl aus:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
Führen Sie in PowerShell den folgenden `Invoke-WebRequest` Befehl aus:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Die Container-ID erhalten.
```
docker ps
```
1. Verwenden Sie den Befehl [docker kill](https://docs.docker.com/engine/reference/commandline/kill/), um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl `3766c4ab331c` durch die Container-ID aus dem vorherigen Schritt.
```
docker kill 3766c4ab331c
```
### Das Image bereitstellen
**Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen**
1. Führen Sie den [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)Befehl aus, um die Docker-CLI bei Ihrer Amazon ECR-Registrierung zu authentifizieren.
+ Setzen Sie den `--region` Wert auf den AWS-Region Ort, an dem Sie das Amazon ECR-Repository erstellen möchten.
+ Ersetzen Sie es `111122223333` durch Ihre AWS-Konto ID.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Erstellen Sie ein Repository in Amazon ECR mithilfe des Befehls [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**Anmerkung**
Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden.
Wenn erfolgreich, sehen Sie eine Antwort wie diese:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Kopieren Sie das `repositoryUri` aus der Ausgabe im vorherigen Schritt.
1. Führen Sie den Befehl [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) aus, um Ihr lokales Image als neueste Version in Ihrem Amazon-ECR-Repository zu markieren. In diesem Befehl gilt Folgendes:
+ `docker-image:test` ist der Name und das [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag) Ihres Docker-Images. Dies sind der Imagename und das Tag, die Sie im `docker build`-Befehl angegeben haben.
+ Ersetzen Sie `` durch den `repositoryUri`, den Sie kopiert haben. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
docker tag docker-image:test :latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Führen Sie den Befehl [docker push](https://docs.docker.com/engine/reference/commandline/push/) aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie `:latest` am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Erstellen Sie eine Ausführungsrolle](lambda-intro-execution-role.md#permissions-executionrole-api) für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
1. So erstellen Sie die Lambda-Funktion: Geben Sie für `ImageUri` die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Anmerkung**
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter [Kontoübergreifende Berechtigungen von Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Die Funktion aufrufen.
```
aws lambda invoke --function-name hello-world response.json
```
Das Ergebnis sollte ungefähr wie folgt aussehen:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Um die Ausgabe der Funktion zu sehen, überprüfen Sie die `response.json`-Datei.
Um den Funktionscode zu aktualisieren, müssen Sie das Image erneut erstellen, das neue Image in das Amazon ECR-Repository hochladen und dann den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, um das Image für die Lambda-Funktion bereitzustellen.
Lambda löst das Image-Tag in einen bestimmten Image-Digest auf. Das heißt, wenn Sie das Image-Tag, das zur Bereitstellung der Funktion verwendet wurde, auf ein neues Image in Amazon ECR verweisen, aktualisiert Lambda die Funktion nicht automatisch, um das neue Image zu verwenden.
Um das neue Image für dieselbe Lambda-Funktion bereitzustellen, müssen Sie den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, auch wenn das Image-Tag in Amazon ECR gleich bleibt. Im folgenden Beispiel erstellt die `--publish`-Option eine neue Version der Funktion unter Verwendung des aktualisierten Container-Images.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Verwenden eines alternativen Basis-Images mit dem Laufzeitschnittstellen-Client
Wenn Sie ein [OS-Basis-Image](images-create.md#runtimes-images-provided) oder ein alternatives Basis-Image verwenden, müssen Sie den Laufzeitschnittstellen-Client in das Image einbinden. Der Laufzeitschnittstellen-Client erweitert die [Laufzeit-API](runtimes-api.md), die die Interaktion zwischen Lambda und Ihrem Funktionscode verwaltet.
Installieren Sie den [Lambda Runtime Interface Client für Ruby](https://rubygems.org/gems/aws_lambda_ric) mit dem Paketmanager RubyGems .org:
```
gem install aws_lambda_ric
```
Sie können den [Ruby-Runtime-Interface-Client](https://github.com/aws/aws-lambda-ruby-runtime-interface-client) auch von GitHub herunterladen.
Das folgende Beispiel zeigt, wie ein Container-Image für Ruby mithilfe eines AWS Nicht-Basis-Images erstellt wird. Das Beispiel-Dockerfile verwendet ein offizielles Ruby-Basis-Image. Das Docker-File enthält den Laufzeitschnittstellen-Client.
### Voraussetzungen
Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:
+ [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (Mindestversion 25.0.0)
+ Das Docker-[buildx-Plugin](https://github.com/docker/buildx/blob/master/README.md).
+ Ruby
### Erstellen eines Images aus einem alternativen Basis-Image
**Erstellen eines Container-Images für Ruby mit einem alternativen Basis-Image**
1. Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir example
cd example
```
1. Erstellen Sie eine neue Datei mit dem Namen `Gemfile`. Hier listen Sie die benötigten RubyGems Pakete für Ihre Anwendung auf. Das AWS SDK für Ruby ist erhältlich bei RubyGems. Sie sollten bestimmte AWS Service Gems für die Installation auswählen. Um beispielsweise das [Ruby-Gem für Lambda](https://rubygems.org/gems/aws-sdk-lambda/) zu verwenden, sollte Ihr Gemfile so aussehen:
```
source 'https://rubygems.org'
gem 'aws-sdk-lambda'
```
Alternativ enthält das [aws-sdk-Gem](https://rubygems.org/gems/aws-sdk/) jedes verfügbare AWS Service-Gem. Dieses Gem ist sehr groß. Wir empfehlen, es nur zu verwenden, wenn Sie auf viele AWS Dienste angewiesen sind.
1. Installieren Sie die im Gemfile angegebenen Abhängigkeiten mithilfe von [bundle install](https://bundler.io/v2.4/man/bundle-install.1.html).
```
bundle install
```
1. Erstellen Sie eine neue Datei mit dem Namen `lambda_function.rb`. Sie können der Datei zum Testen den folgenden Beispielfunktionscode hinzufügen oder Ihren eigenen verwenden.
**Example Ruby-Funktion**
```
module LambdaFunction
class Handler
def self.process(event:,context:)
"Hello from Lambda!"
end
end
end
```
1. Erstellen Sie eine neue Docker-Datei. Das folgende Dockerfile verwendet ein Ruby-Basis-Image anstelle eines [AWS -Basis-Images](images-create.md#runtimes-images-lp). Das Dockerfile enthält den [Laufzeitschnittstellen-Client für Ruby](https://github.com/aws/aws-lambda-ruby-runtime-interface-client), der das Image mit Lambda kompatibel macht. Alternativ können Sie den Laufzeitschnittstellen-Client zum Gemfile Ihrer Anwendung hinzufügen.
+ Legen Sie die `FROM`-Eigenschaft auf das Ruby-Basis-Image fest.
+ Erstellen Sie ein Verzeichnis für den Funktionscode und eine Umgebungsvariable, die auf dieses Verzeichnis verweist. In diesem Beispiel ist das Verzeichnis `/var/task`, das die Lambda-Ausführungsumgebung widerspiegelt. Sie können jedoch ein beliebiges Verzeichnis für den Funktionscode wählen, da das Dockerfile kein AWS Basis-Image verwendet.
+ Legen Sie `ENTRYPOINT` auf das Modul fest, das der Docker-Container beim Start ausführen soll. In diesem Fall ist das Modul der Laufzeitschnittstellen-Client.
+ Legen Sie das `CMD`-Argument auf den Lambda-Funktionshandler fest.
Beachten Sie, dass das Dockerfile-Beispiel keine [USER-Anweisung](https://docs.docker.com/reference/dockerfile/#user) enthält. Wenn Sie ein Container-Image für Lambda bereitstellen, definiert Lambda automatisch einen Standard-Linux-Benutzer mit Berechtigungen mit geringsten Rechten. Dies unterscheidet sich vom Standardverhalten von Docker, bei dem standardmäßig der `root`-Benutzer verwendet wird, wenn keine `USER`-Anweisung bereitgestellt wird.
**Example Dockerfile**
```
FROM ruby:2.7
# Install the runtime interface client for Ruby
RUN gem install aws_lambda_ric
# Add the runtime interface client to the PATH
ENV PATH="/usr/local/bundle/bin:${PATH}"
# Create a directory for the Lambda function
ENV LAMBDA_TASK_ROOT=/var/task
RUN mkdir -p ${LAMBDA_TASK_ROOT}
WORKDIR ${LAMBDA_TASK_ROOT}
# Copy Gemfile and Gemfile.lock
COPY Gemfile Gemfile.lock ${LAMBDA_TASK_ROOT}/
# Install Bundler and the specified gems
RUN gem install bundler:2.4.20 && \
bundle config set --local path 'vendor/bundle' && \
bundle install
# Copy function code
COPY lambda_function.rb ${LAMBDA_TASK_ROOT}/
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "aws_lambda_ric" ]
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.LambdaFunction::Handler.process" ]
```
1. Erstellen Sie Ihr Docker-Image mit dem [docker build](https://docs.docker.com/engine/reference/commandline/build/)-Befehl. Das folgende Beispiel benennt das Bild in `docker-image` und gibt ihm den `test` [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag). Um Ihr Image mit Lambda kompatibel zu machen, müssen Sie die Option `--provenance=false` verwenden.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**Anmerkung**
Der Befehl gibt die `--platform linux/amd64`-Option an, um sicherzustellen, dass Ihr Container mit der Lambda-Ausführungsumgebung kompatibel ist, unabhängig von der Architektur des Entwicklungsrechners. Wenn Sie beabsichtigen, eine Lambda-Funktion mithilfe der ARM64 Befehlssatzarchitektur zu erstellen, müssen Sie den Befehl so ändern, dass er stattdessen die `--platform linux/arm64` Option verwendet.
### (Optional) Testen Sie das Image lokal
Verwenden Sie den [Laufzeit-Schnittstellen-Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator/), um das Image lokal zu testen. Sie können [den Emulator in Ihr Image integrieren](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) oder ihn mit dem folgenden Verfahren auf Ihrem lokalen Computer installieren.
**Installieren des Laufzeitschnittstellen-Emulators auf Ihrem lokalen Computer**
1. Führen Sie in Ihrem Projektverzeichnis den folgenden Befehl aus, um den Runtime-Interface-Emulator (x86-64-Architektur) herunterzuladen GitHub und auf Ihrem lokalen Computer zu installieren.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Um den arm64-Emulator zu installieren, ersetzen Sie die GitHub Repository-URL im vorherigen Befehl durch Folgendes:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Um den arm64-Emulator zu installieren, ersetzen Sie das `$downloadLink` durch Folgendes:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Starten Sie Ihr Docker-Image mit dem **docker run**-Befehl. Beachten Sie Folgendes:
+ `docker-image` ist der Image-Name und `test` ist das Tag.
+ `aws_lambda_ric lambda_function.LambdaFunction::Handler.process` ist der `ENTRYPOINT` gefolgt von dem `CMD` aus Ihrem Dockerfile.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
aws_lambda_ric lambda_function.LambdaFunction::Handler.process
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
aws_lambda_ric lambda_function.LambdaFunction::Handler.process
```
------
Dieser Befehl führt das Image als Container aus und erstellt einen lokalen Endpunkt bei `localhost:9000/2015-03-31/functions/function/invocations`.
**Anmerkung**
Wenn Sie das Docker-Image für die ARM64 Befehlssatzarchitektur erstellt haben, stellen Sie sicher, dass Sie die `--platform linux/arm64` Option anstelle von verwenden. `--platform linux/amd64`
1. Veröffentlichen Sie ein Ereignis auf dem lokalen Endpunkt.
------
#### [ Linux/macOS ]
Führen Sie unter Linux oder macOS den folgenden `curl`-Befehl aus:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
Führen Sie in PowerShell den folgenden `Invoke-WebRequest` Befehl aus:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Dieser Befehl ruft die Funktion mit einem leeren Ereignis auf und gibt eine Antwort zurück. Wenn Sie Ihren eigenen Funktionscode anstelle des Beispielfunktionscodes verwenden, wird empfohlen, die Funktion mit einer JSON-Nutzlast aufzurufen. Beispiel:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Die Container-ID erhalten.
```
docker ps
```
1. Verwenden Sie den Befehl [docker kill](https://docs.docker.com/engine/reference/commandline/kill/), um den Container zu anzuhalten. Ersetzen Sie in diesem Befehl `3766c4ab331c` durch die Container-ID aus dem vorherigen Schritt.
```
docker kill 3766c4ab331c
```
### Das Image bereitstellen
**Um das Image in Amazon ECR hochzuladen und die Lambda-Funktion zu erstellen**
1. Führen Sie den [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)Befehl aus, um die Docker-CLI bei Ihrer Amazon ECR-Registrierung zu authentifizieren.
+ Setzen Sie den `--region` Wert auf den AWS-Region Ort, an dem Sie das Amazon ECR-Repository erstellen möchten.
+ Ersetzen Sie es `111122223333` durch Ihre AWS-Konto ID.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Erstellen Sie ein Repository in Amazon ECR mithilfe des Befehls [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**Anmerkung**
Das Amazon ECR-Repository muss sich im selben Format AWS-Region wie die Lambda-Funktion befinden.
Wenn erfolgreich, sehen Sie eine Antwort wie diese:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Kopieren Sie das `repositoryUri` aus der Ausgabe im vorherigen Schritt.
1. Führen Sie den Befehl [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) aus, um Ihr lokales Image als neueste Version in Ihrem Amazon-ECR-Repository zu markieren. In diesem Befehl gilt Folgendes:
+ `docker-image:test` ist der Name und das [Tag](https://docs.docker.com/engine/reference/commandline/build/#tag) Ihres Docker-Images. Dies sind der Imagename und das Tag, die Sie im `docker build`-Befehl angegeben haben.
+ Ersetzen Sie `` durch den `repositoryUri`, den Sie kopiert haben. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
docker tag docker-image:test :latest
```
Beispiel:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Führen Sie den Befehl [docker push](https://docs.docker.com/engine/reference/commandline/push/) aus, um Ihr lokales Image im Amazon-ECR-Repository bereitzustellen. Stellen Sie sicher, dass Sie `:latest` am Ende der Repository-URI angeben.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Erstellen Sie eine Ausführungsrolle](lambda-intro-execution-role.md#permissions-executionrole-api) für die Funktion, wenn Sie noch keine haben. Sie benötigen den Amazon-Ressourcennamen (ARN) der Rolle im nächsten Schritt.
1. So erstellen Sie die Lambda-Funktion: Geben Sie für `ImageUri` die Repository-URI von zuvor an. Stellen Sie sicher, dass Sie `:latest` am Ende der URI angeben.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**Anmerkung**
Sie können eine Funktion mit einem Bild in einem anderen AWS Konto erstellen, sofern sich das Bild in derselben Region wie die Lambda-Funktion befindet. Weitere Informationen finden Sie unter [Kontoübergreifende Berechtigungen von Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Die Funktion aufrufen.
```
aws lambda invoke --function-name hello-world response.json
```
Das Ergebnis sollte ungefähr wie folgt aussehen:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Um die Ausgabe der Funktion zu sehen, überprüfen Sie die `response.json`-Datei.
Um den Funktionscode zu aktualisieren, müssen Sie das Image erneut erstellen, das neue Image in das Amazon ECR-Repository hochladen und dann den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, um das Image für die Lambda-Funktion bereitzustellen.
Lambda löst das Image-Tag in einen bestimmten Image-Digest auf. Das heißt, wenn Sie das Image-Tag, das zur Bereitstellung der Funktion verwendet wurde, auf ein neues Image in Amazon ECR verweisen, aktualisiert Lambda die Funktion nicht automatisch, um das neue Image zu verwenden.
Um das neue Image für dieselbe Lambda-Funktion bereitzustellen, müssen Sie den [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)Befehl verwenden, auch wenn das Image-Tag in Amazon ECR gleich bleibt. Im folgenden Beispiel erstellt die `--publish`-Option eine neue Version der Funktion unter Verwendung des aktualisierten Container-Images.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
# 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.
# Verwenden des Lambda-Kontextobjekts zum Abrufen von Ruby-Funktionsinformationen
Wenn Lambda Ihre Funktion ausführt, wird ein Context-Objekt an den [Handler](ruby-handler.md). übergeben. Dieses Objekt stellt Methoden und Eigenschaften mit Informationen zum Aufruf, zur Funktion und zur Ausführungsumgebung bereit.
**Context-Methoden**
+ `get_remaining_time_in_millis` – Gibt die Anzahl der verbleibenden Millisekunden zurück, bevor die Ausführung das Zeitlimit überschreitet.
**Context-Eigenschaften**
+ `function_name` – Der Name der Lambda-Funktion.
+ `function_version` – Die [Version](configuration-versions.md) der Funktion.
+ `invoked_function_arn` – Der Amazon-Ressourcenname (ARN), der zum Aufrufen der Funktion verwendet wird. Gibt an, ob der Aufrufer eine Versionsnummer oder einen Alias angegeben hat.
+ `memory_limit_in_mb` – Die Menge an Arbeitsspeicher, die der Funktion zugewiesen ist.
+ `aws_request_id` – Der Bezeichner der Aufrufanforderung.
+ `log_group_name` – Protokollgruppe für die Funktion.
+ `log_stream_name` – Der Protokollstrom für die Funktionsinstance.
+ `deadline_ms` – Das Datum, an dem eine Zeitüberschreitung für die Ausführung eintritt (in Unix-Millisekunden).
+ `identity` – Informationen zur Amazon-Cognito-Identität, die die Anforderung autorisiert hat.
+ `client_context` – (mobile Apps) Clientkontext, der Lambda von der Clientanwendung bereitgestellt wird.
# Ruby-Lambda-Funktionen protokollieren und überwachen
AWS Lambda überwacht automatisch Lambda-Funktionen in Ihrem Namen und sendet Protokolle an Amazon CloudWatch. Ihre Lambda-Funktion enthält eine CloudWatch Logs-Log-Gruppe und einen Log-Stream für jede Instanz Ihrer Funktion. Die Lambda-Laufzeitumgebung sendet Details zu den einzelnen Aufrufen an den Protokollstream und leitet Protokolle und andere Ausgaben aus dem Code Ihrer Funktion weiter. Weitere Informationen finden Sie unter [Senden von Lambda-Funktionsprotokollen an CloudWatch Logs](monitoring-cloudwatchlogs.md).
Auf dieser Seite wird beschrieben, wie Sie eine Protokollausgabe aus dem Code Ihrer Lambda-Funktion erstellen und mithilfe der AWS Command Line Interface Lambda-Konsole oder der CloudWatch Konsole auf Logs zugreifen.
**Topics**
+ [Erstellen einer Funktion, die Protokolle zurückgibt](#ruby-logging-output)
+ [Anzeigen von Protokollen in der Lambda-Konsole](#ruby-logging-console)
+ [Protokolle in der Konsole anzeigen CloudWatch](#ruby-logging-cwconsole)
+ [Logs mit dem Befehl () anzeigen AWS Command Line Interface AWS CLI](#ruby-logging-cli)
+ [Löschen von Protokollen](#ruby-logging-delete)
+ [Arbeiten mit der Ruby-Logger-Bibliothek](#ruby-logging-lib)
## Erstellen einer Funktion, die Protokolle zurückgibt
Um Protokolle aus dem Code Ihrer Funktion auszugeben, können Sie `puts`-Anweisungen verwenden oder eine Protokollierungsbibliothek, die zu `stdout` oder `stderr` schreibt. Das folgende Beispiel protokolliert die Werte der Umgebungsvariablen und dem Ereignisobjekt.
**Example lambda\$1function.rb**
```
# lambda_function.rb
def handler(event:, context:)
puts "## ENVIRONMENT VARIABLES"
puts ENV.to_a
puts "## EVENT"
puts event.to_a
end
```
**Example Protokollformat**
```
START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled: true
```
Die Ruby-Laufzeit protokolliert die Zeilen `START`, `END` und `REPORT` für jeden Aufruf. Die Berichtszeile enthält die folgenden Details.
**Datenfelder für REPORT-Zeilen**
+ **RequestId**— Die eindeutige Anforderungs-ID für den Aufruf.
+ **Dauer** – Die Zeit, die die Handler-Methode Ihrer Funktion mit der Verarbeitung des Ereignisses verbracht hat.
+ **Fakturierte Dauer** – Die für den Aufruf fakturierte Zeit.
+ **Speichergröße** – Die der Funktion zugewiesene Speichermenge.
+ **Max. verwendeter Speicher** – Die Speichermenge, die von der Funktion verwendet wird. Wenn Aufrufe eine Ausführungsumgebung gemeinsam nutzen, meldet Lambda den maximalen Speicherverbrauch für alle Aufrufe. Dieses Verhalten kann zu einem höheren als erwarteten gemeldeten Wert führen.
+ **Initialisierungsdauer** – Für die erste Anfrage die Zeit, die zur Laufzeit zum Laden der Funktion und Ausführen von Code außerhalb der Handler-Methode benötigt wurde.
+ **XRAY TraceId** [— Für verfolgte Anfragen die AWS X-Ray Trace-ID.](services-xray.md)
+ **SegmentId**— Für verfolgte Anfragen die X-Ray-Segment-ID.
+ **Stichprobe** – Bei verfolgten Anforderungen das Stichprobenergebnis.
Für detailliertere Protokolle verwenden Sie die [Arbeiten mit der Ruby-Logger-Bibliothek](#ruby-logging-lib).
## Anzeigen von Protokollen in der Lambda-Konsole
Sie können die Lambda-Konsole verwenden, um die Protokollausgabe nach dem Aufrufen einer Lambda-Funktion anzuzeigen.
Wenn Ihr Code über den eingebetteten **Code**-Editor getestet werden kann, finden Sie Protokolle in den **Ausführungsergebnissen**. Wenn Sie das Feature Konsolentest verwenden, um eine Funktion aufzurufen, finden Sie die **Protokollausgabe** im Abschnitt **Details**.
## Protokolle in der Konsole anzeigen CloudWatch
Sie können die CloudWatch Amazon-Konsole verwenden, um Protokolle für alle Lambda-Funktionsaufrufe anzuzeigen.
**Um Protokolle auf der Konsole anzuzeigen CloudWatch**
1. Öffnen Sie die [Seite Protokollgruppen](https://console.aws.amazon.com/cloudwatch/home?#logs:) auf der CloudWatch Konsole.
1. Wählen Sie die Protokollgruppe für Ihre Funktion (***your-function-name*/aws/lambda/**).
1. Wählen Sie eine Protokollstream aus.
Jeder Protokoll-Stream entspricht einer [Instance Ihrer Funktion](lambda-runtime-environment.md). Ein Protokollstream wird angezeigt, wenn Sie Ihre Lambda-Funktion aktualisieren und wenn zusätzliche Instanzen für gleichzeitige Aufrufe erstellt werden. Um Logs für einen bestimmten Aufruf zu finden, empfehlen wir, Ihre Funktion mit zu instrumentieren. AWS X-Ray X-Ray erfasst Details zu der Anforderung und dem Protokollstream in der Trace.
## Logs mit dem Befehl () anzeigen AWS Command Line Interface AWS CLI
Das AWS CLI ist ein Open-Source-Tool, mit dem Sie mithilfe von Befehlen in Ihrer Befehlszeilen-Shell mit AWS Diensten interagieren können. Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie [AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Sie können die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) verwenden, um Protokolle für einen Aufruf mit der `--log-type`-Befehlsoption abzurufen. Die Antwort enthält das Feld `LogResult`, das bis zu 4 KB base64-verschlüsselte Protokolle aus dem Aufruf enthält.
**Example eine Log-ID abrufen**
Das folgende Beispiel zeigt, wie eine *Protokoll-ID* aus dem `LogResult`-Feld für eine Funktion namens `my-function` abgerufen wird.
```
aws lambda invoke --function-name my-function out --log-type Tail
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example entschlüsseln der Protokolle**
Verwenden Sie in derselben Eingabeaufforderung das `base64`-Dienstprogramm, um die Protokolle zu entschlüsseln. Das folgende Beispiel zeigt, wie Base64-codierte Logs für abgerufen werde `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
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*.
Die Ausgabe sollte folgendermaßen aussehen:
```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB
```
Das `base64`-Dienstprogramm ist unter Linux, macOS und [Ubuntu auf Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10)verfügbar. macOS-Benutzer müssen möglicherweise `base64 -D` verwenden.
**Example get-logs.sh-Skript**
Verwenden Sie in derselben Eingabeaufforderung das folgende Skript, um die letzten fünf Protokollereignisse herunterzuladen. Das Skript verwendet `sed` zum Entfernen von Anführungszeichen aus der Ausgabedatei und wechselt 15 Sekunden lang in den Ruhezustand, um Zeit einzuräumen, damit Protokolle verfügbar werden können. Die Ausgabe enthält die Antwort von Lambda und die `get-log-events`Ausgabe des Befehls.
Kopieren Sie den Inhalt des folgenden Codebeispiels und speichern Sie es in Ihrem Lambda-Projektverzeichnis unter `get-logs.sh`.
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*.
```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```
**Example macOS und Linux (nur diese Systeme)**
In derselben Eingabeaufforderung müssen macOS- und Linux-Benutzer möglicherweise den folgenden Befehl ausführen, um sicherzustellen, dass das Skript ausführbar ist.
```
chmod -R 755 get-logs.sh
```
**Example die letzten fünf Protokollereignisse abrufen**
Führen Sie an derselben Eingabeaufforderung das folgende Skript aus, um die letzten fünf Protokollereignisse abzurufen.
```
./get-logs.sh
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```
## Löschen von Protokollen
Wenn Sie eine Funktion löschen, werden Protokollgruppen nicht automatisch gelöscht. Um das unbegrenzte Speichern von Protokollen zu vermeiden, löschen Sie die Protokollgruppe oder [konfigurieren Sie eine Aufbewahrungszeitraum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) nach dem Protokolle automatisch gelöscht werden.
## Arbeiten mit der Ruby-Logger-Bibliothek
Die [Ruby-Logger-Bibliothek](https://ruby-doc.org/stdlib-2.7.0/libdoc/logger/rdoc/index.html) gibt optimierte Protokolle zurück, die leicht zu lesen sind. Verwenden Sie das Logger-Serviceprogramm, um detaillierte Informationen, Meldungen und Fehlercodes im Zusammenhang mit Ihrer Funktion auszugeben.
```
# lambda_function.rb
require 'logger'
def handler(event:, context:)
logger = Logger.new($stdout)
logger.info('## ENVIRONMENT VARIABLES')
logger.info(ENV.to_a)
logger.info('## EVENT')
logger.info(event)
event.to_a
end
```
Die Ausgabe aus `logger` umfasst die Protokollebene, den Zeitstempel und die Anforderungs-ID.
```
START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT VARIABLES
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key': 'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled: true
```
# Instrumentierung von Ruby-Code in AWS Lambda
Lambda lässt sich integrieren AWS X-Ray , damit Sie Lambda-Anwendungen verfolgen, debuggen und optimieren können. Sie können mit X-Ray eine Anforderung verfolgen, während sie Ressourcen in Ihrer Anwendung durchläuft, von der Frontend-API bis hin zu Speicher und Datenbank im Backend. Indem Sie einfach die X-Ray-SDK-Bibliothek zu Ihrer Build-Konfiguration hinzufügen, können Sie Fehler und Latenz für jeden Aufruf aufzeichnen, den Ihre Funktion an einen AWS Dienst tätigt.
Nachdem Sie die aktive Nachverfolgung konfiguriert haben, können Sie bestimmte Anfragen über Ihre Anwendung beobachten. Das [X-Ray-Service-Diagramm](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) zeigt Informationen über Ihre Anwendung und alle ihre Komponenten an. Das folgende Beispiel zeigt eine Anwendung mit zwei Funktionen. Die primäre Funktion verarbeitet Ereignisse und gibt manchmal Fehler zurück. Die zweite Funktion an oberster Stelle verarbeitet Fehler, die in der Protokollgruppe der ersten auftreten, und verwendet das AWS SDK, um X-Ray, Amazon Simple Storage Service (Amazon S3) und Amazon CloudWatch Logs aufzurufen.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
Gehen Sie folgendermaßen vor, um die aktive Nachverfolgung Ihrer Lambda-Funktion mit der Konsole umzuschalten:
**So aktivieren Sie die aktive Nachverfolgung**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie eine Funktion aus.
1. Wählen Sie **Configuration** (Konfiguration) und dann **Monitoring and operations tools** (Überwachungs- und Produktionstools).
1. Wählen Sie unter **Zusätzliche Überwachungstools** die Option **Bearbeiten** aus.
1. Wählen Sie unter **CloudWatch Anwendungssignale und AWS X-Ray** die Option **Enable** for **Lambda Service Traces** aus.
1. Wählen Sie **Speichern**.
**Preisgestaltung**
Im Rahmen des kostenlosen Kontingents können Sie X-Ray Tracing jeden Monat bis zu einem bestimmten Limit AWS kostenlos nutzen. Über den Schwellenwert hinaus berechnet X-Ray Gebühren für die Speicherung und den Abruf der Nachverfolgung. Weitere Informationen finden Sie unter [AWS X-Ray Preise](https://aws.amazon.com/xray/pricing/).
Ihre Funktion benötigt die Berechtigung zum Hochladen von Trace-Daten zu X-Ray. Wenn Sie die aktive Nachverfolgung in der Lambda-Konsole aktivieren, fügt Lambda der [Ausführungsrolle](lambda-intro-execution-role.md) Ihrer Funktion die erforderlichen Berechtigungen hinzu. Andernfalls fügen Sie die [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess)Richtlinie der Ausführungsrolle hinzu.
X-Ray verfolgt nicht alle Anfragen an Ihre Anwendung nach. X-Ray wendet einen Sampling-Algorithmus an, um sicherzustellen, dass die Nachverfolgung effizient ist, und stellt dennoch ein repräsentatives Beispiel aller Anfragen bereit. Die Samplingrate beträgt 1 Anforderung pro Sekunde und 5 Prozent aller weiteren Anforderungen. Sie können die X-Ray-Samplingrate nicht für Ihre Funktionen konfigurieren.
In X-Ray, zeichnet eine *Ablaufverfolgung* Informationen zu einer Anforderung auf, die von einem oder mehreren *Services* verarbeitet wird. Lambda zeichnet 2 Segmente pro Trace auf, wodurch zwei Knoten im Dienstgraphen entstehen. In der folgenden Abbildung werden diese beiden Knoten hervorgehoben:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/xray-servicemap-function.png)
Der erste Knoten auf der linken Seite stellt den Lambda-Service dar, der die Aufrufanforderung empfängt. Der zweite Knoten stellt Ihre spezifische Lambda-Funktion dar. Das folgende Beispiel zeigt eine Nachverfolgung mit diesen zwei Segmenten. Beide heißen **my-function**, aber einer hat einen Ursprung von `AWS::Lambda` und der andere hat einen Ursprung von `AWS::Lambda::Function`. Wenn das `AWS::Lambda`-Segment einen Fehler anzeigt, hatte der Lambda-Service ein Problem. Wenn das `AWS::Lambda::Function`-Segment einen Fehler anzeigt, ist bei Ihrer Funktion ein Problem aufgetreten.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
Dieses Beispiel erweitert das `AWS::Lambda::Function`-Segment, um seine drei Untersegmente anzuzeigen.
**Anmerkung**
AWS implementiert derzeit Änderungen am Lambda-Service. Aufgrund dieser Änderungen können geringfügige Unterschiede in Struktur und Inhalt der Systemprotokollmeldungen und Trace-Segmente auftreten, die von verschiedenen Lambda-Funktionen in Ihrem AWS-Konto.
Der hier gezeigte Beispiel-Trace veranschaulicht das Funktionssegment im alten Stil. Die Unterschiede zwischen den Segmenten im alten und im neuen Stil werden in den folgenden Abschnitten beschrieben.
Diese Änderungen werden in den kommenden Wochen umgesetzt, und alle Funktionen AWS-Regionen außer China und den GovCloud Regionen werden auf die Verwendung der Protokollnachrichten und Trace-Segmente im neuen Format umgestellt.
Das Funktionssegment im alten Stil enthält die folgenden Untersegmente:
+ **Initialisierung** – Stellt die Zeit dar, die für das Laden Ihrer Funktion und das Ausführen des [Initialisierungscodes](foundation-progmodel.md) aufgewendet wurde. Dieses Untersegment erscheint nur für das erste Ereignis, das jede Instance Ihrer Funktion verarbeitet.
+ **Invocation** (Aufruf) – Stellt die Zeit dar, die beim Ausführen Ihres Handler-Codes vergeht.
+ **Overhead** (Aufwand) – Stellt die Zeit dar, die von der Lambda-Laufzeitumgebung bei der Verarbeitung des nächsten Ereignisses verbraucht wird.
Das Funktionssegment im neuen Stil enthält kein `Invocation`-Untersegment. Stattdessen werden Kundenuntersegmente direkt an das Funktionssegment angehängt. Weitere Informationen über die Struktur der alten und neuen Funktionssegmente finden Sie unter [Grundlegendes zu X-Ray-Ablaufverfolgungen](services-xray.md#services-xray-traces).
Sie können Ihren Handler-Code instrumentieren, um Metadaten aufzuzeichnen und Downstream-Aufrufe nachzuverfolgen. Um Details zu Aufrufen aufzuzeichnen, die Ihr Handler an andere Ressourcen und Services macht, verwenden Sie das X-Ray-SDK für Ruby. Um das SDK zu erhalten, fügen Sie das `aws-xray-sdk`-Paket den Abhängigkeiten Ihrer Anwendung hinzu.
**Example [leer- ruby/function/Gemfile](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/function/Gemfile)**
```
# Gemfile
source 'https://rubygems.org'
gem 'aws-xray-sdk', '0.11.4'
gem 'aws-sdk-lambda', '1.39.0'
gem 'test-unit', '3.3.5'
```
Um AWS SDK-Clients zu instrumentieren, benötigen Sie das `aws-xray-sdk/lambda` Modul, nachdem Sie einen Client im Initialisierungscode erstellt haben.
**Example [blank- ruby/function/lambda \$1function.rb](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/function/lambda_function.rb) — Einen SDK-Client verfolgen AWS**
```
# lambda_function.rb
require 'logger'
require 'json'
require 'aws-sdk-lambda'
$client = Aws::Lambda::Client.new()
$client.get_account_settings()
require 'aws-xray-sdk/lambda'
def lambda_handler(event:, context:)
logger = Logger.new($stdout)
...
```
In X-Ray, zeichnet eine *Ablaufverfolgung* Informationen zu einer Anforderung auf, die von einem oder mehreren *Services* verarbeitet wird. Lambda zeichnet 2 Segmente pro Trace auf, wodurch zwei Knoten im Dienstgraphen entstehen. In der folgenden Abbildung werden diese beiden Knoten hervorgehoben:
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/xray-servicemap-function.png)
Der erste Knoten auf der linken Seite stellt den Lambda-Service dar, der die Aufrufanforderung empfängt. Der zweite Knoten stellt Ihre spezifische Lambda-Funktion dar. Das folgende Beispiel zeigt eine Nachverfolgung mit diesen zwei Segmenten. Beide heißen **my-function**, aber einer hat einen Ursprung von `AWS::Lambda` und der andere hat einen Ursprung von `AWS::Lambda::Function`. Wenn das `AWS::Lambda`-Segment einen Fehler anzeigt, hatte der Lambda-Service ein Problem. Wenn das `AWS::Lambda::Function`-Segment einen Fehler anzeigt, ist bei Ihrer Funktion ein Problem aufgetreten.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
Dieses Beispiel erweitert das `AWS::Lambda::Function`-Segment, um seine drei Untersegmente anzuzeigen.
**Anmerkung**
AWS implementiert derzeit Änderungen am Lambda-Service. Aufgrund dieser Änderungen können geringfügige Unterschiede in Struktur und Inhalt der Systemprotokollmeldungen und Trace-Segmente auftreten, die von verschiedenen Lambda-Funktionen in Ihrem AWS-Konto.
Der hier gezeigte Beispiel-Trace veranschaulicht das Funktionssegment im alten Stil. Die Unterschiede zwischen den Segmenten im alten und im neuen Stil werden in den folgenden Abschnitten beschrieben.
Diese Änderungen werden in den kommenden Wochen umgesetzt, und alle Funktionen AWS-Regionen außer China und den GovCloud Regionen werden auf die Verwendung der Protokollnachrichten und Trace-Segmente im neuen Format umgestellt.
Das Funktionssegment im alten Stil enthält die folgenden Untersegmente:
+ **Initialisierung** – Stellt die Zeit dar, die für das Laden Ihrer Funktion und das Ausführen des [Initialisierungscodes](foundation-progmodel.md) aufgewendet wurde. Dieses Untersegment erscheint nur für das erste Ereignis, das jede Instance Ihrer Funktion verarbeitet.
+ **Invocation** (Aufruf) – Stellt die Zeit dar, die beim Ausführen Ihres Handler-Codes vergeht.
+ **Overhead** (Aufwand) – Stellt die Zeit dar, die von der Lambda-Laufzeitumgebung bei der Verarbeitung des nächsten Ereignisses verbraucht wird.
Das Funktionssegment im neuen Stil enthält kein `Invocation`-Untersegment. Stattdessen werden Kundenuntersegmente direkt an das Funktionssegment angehängt. Weitere Informationen über die Struktur der alten und neuen Funktionssegmente finden Sie unter [Grundlegendes zu X-Ray-Ablaufverfolgungen](services-xray.md#services-xray-traces).
Sie können auch HTTP-Clients instrumentieren, SQL-Abfragen aufzeichnen und benutzerdefinierte Untersegmente mit Anmerkungen und Metadaten erstellen. Weitere Informationen finden Sie unter [Das X-Ray-SDK SDK for Ruby](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-ruby.html) im AWS X-Ray Entwicklerhandbuch.
**Topics**
+ [Aktivieren der aktiven Ablaufverfolgung mit der Lambda-API](#ruby-tracing-api)
+ [Aktivierung der aktiven Ablaufverfolgung mit CloudFormation](#ruby-tracing-cloudformation)
+ [Speichern von Laufzeitabhängigkeiten in einer Ebene](#ruby-tracing-layers)
## Aktivieren der aktiven Ablaufverfolgung mit der Lambda-API
Verwenden Sie die folgenden API-Operationen, um die Tracing-Konfiguration mit dem AWS SDK AWS CLI oder zu verwalten:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
**Der folgende AWS CLI Beispielbefehl aktiviert die aktive Ablaufverfolgung für eine Funktion namens my-function.**
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
Der Ablaufverfolgungsmodus ist Teil der versionsspezifischen Konfiguration, wenn Sie eine Version Ihrer Funktion veröffentlichen. Sie können den Ablaufverfolgungsmodus für eine veröffentlichte Version nicht ändern.
## Aktivierung der aktiven Ablaufverfolgung mit CloudFormation
Um die Ablaufverfolgung für eine `AWS::Lambda::Function` Ressource in einer CloudFormation Vorlage zu aktivieren, verwenden Sie die `TracingConfig` Eigenschaft.
**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) – Ablaufverfolgungskonfiguration**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Verwenden Sie für eine `AWS::Serverless::Function` Ressource AWS Serverless Application Model (AWS SAM) die `Tracing` Eigenschaft.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Ablaufverfolgungskonfiguration**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Speichern von Laufzeitabhängigkeiten in einer Ebene
Wenn Sie das X-Ray-SDK verwenden, um AWS SDK-Clients Ihren Funktionscode zu instrumentieren, kann Ihr Bereitstellungspaket ziemlich umfangreich werden. Um Laufzeitabhängigkeiten bei jeder Aktualisierung des Funktionscodes zu vermeiden, verpacken Sie das X-Ray-SDK in einer [Lambda-Ebene](chapter-layers.md).
Das folgende Beispiel zeigt eine `AWS::Serverless::LayerVersion`-Ressource, die das X-Ray-SDK für Ruby speichert.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby/template.yml) – Abhängigkeitenebene**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
Properties:
LayerName: blank-ruby-lib
Description: Dependencies for the blank-ruby sample app.
ContentUri: lib/.
CompatibleRuntimes:
- ruby2.5
```
Bei dieser Konfiguration aktualisieren Sie die Bibliotheksebene nur, wenn Sie Ihre Laufzeitabhängigkeiten ändern. Da das Funktionsbereitstellungspaket nur Ihren Code enthält, kann dies dazu beitragen, die Upload-Zeiten zu reduzieren.
Das Erstellen einer Ebene für Abhängigkeiten erfordert Build-Konfigurationsänderungen, um das Ebenen-Archiv vor der Bereitstellung zu generieren. Ein funktionierendes Beispiel finden Sie in der Beispielanwendung [blank-ruby](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-ruby) .