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.

# Definieren des Lambda-Funktions-Handlers in Ruby
<a name="ruby-handler"></a>

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
<a name="ruby-handler-basics"></a>

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
<a name="ruby-best-practices"></a>

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/).