Definieren Sie den Lambda-Funktionshandler in Python - AWS Lambda
BenennungFunktionsweiseRückgabe eines WertesBeispieleBewährte Codemethoden für Python-Lambda-Funktionen

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 Sie den Lambda-Funktionshandler in Python

Der Lambda-Funktionshandler 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.

Sie können die folgende allgemeine Syntax verwenden, wenn Sie einen Funktionshandler in Python erstellen:

def handler_name(event, context): 
    ...
    return some_value

Benennung

Der zum Zeitpunkt der Erstellung einer Lambda-Funktion angegebene Lambda-Funktionshandlername wird abgeleitet von:

  • dem Namen der Datei, in der sich die Lambda-Handler-Funktion befindet.

  • dem Namen der Python-Handler-Funktion.

Ein Funktionshandler kann ein beliebiger Name sein, der Standardname auf der Lambda-Konsole ist jedoch lambda_function.lambda_handler. Dieser Name des Funktionshandlers spiegelt den Funktionsnamen (lambda_handler) und die Datei, in der der Handler-Code gespeichert ist, (lambda_function.py) wider.

Wenn Sie eine Funktion in der Konsole mit einem anderen Dateinamen oder Funktionshandlernamen erstellen, müssen Sie den Standardhandlernamen bearbeiten.

So ändern Sie den Funktionshandlernamen (Konsole)

  1. Öffnen Sie die Seite Functions (Funktionen) der Lambda-Konsole und wählen Sie eine Funktion aus.

  2. Wählen Sie die Registerkarte Code (Code).

  3. Scrollen Sie nach unten zum Bereich Laufzeiteinstellungen und wählen Sie Bearbeiten.

  4. Geben Sie unter Handler den neuen Namen für Ihren Funktionshandler ein.

  5. Wählen Sie Save (Speichern) aus.

Funktionsweise

Wenn Lambda Ihren Funktionshandler aufruft, übergibt die Lambda-Laufzeit zwei Argumente an den Funktionshandler:

  • Das erste Argument ist das Ereignisobjekt. Ein Ereignis ist ein Dokument im JSON -Format, das Daten für die Verarbeitung durch eine Lambda-Funktion enthält. Die Lambda-Laufzeit konvertiert das Ereignis zu einem Objekt und übergibt es an Ihren Funktionscode. Es ist normalerweise vom Python-dict-Typ. Es kann sich aber auch um den Typ list, str, int, float oder NoneType handeln.

    Das Ereignisobjekt enthält Informationen vom aufrufenden Dienst. Wenn Sie eine Funktion aufrufen, bestimmen Sie die Struktur und den Inhalt des Ereignisses. Wenn ein AWS Dienst Ihre Funktion aufruft, definiert der Dienst die Ereignisstruktur. Weitere Hinweise zu Ereignissen von AWS Diensten finden Sie unterLambda mit Ereignissen aus anderen Diensten aufrufen AWS.

  • Das zweite Argument ist das Context-Objekt. Zur Laufzeit wird ein Kontextobjekt von Lambda an Ihre Funktion übergeben. Dieses Objekt stellt Methoden und Eigenschaften mit Informationen zum Aufruf, zur Funktion und zur Laufzeitumgebung bereit.

Rückgabe eines Wertes

Optional kann ein Handler einen Wert zurückgeben. Was mit dem zurückgegebenen Wert passiert, hängt von der Aufrufart und dem Service ab, der die Funktion aufgerufen hat. Beispielsweise:

  • Wenn Sie den RequestResponse Aufruftyp verwenden, z. B.Synchrones Aufrufen einer Lambda-Funktion, wird das Ergebnis des Python-Funktionsaufrufs an den Client AWS Lambda zurückgegeben, der die Lambda-Funktion aufruft (in der HTTP Antwort auf die Aufrufanforderung, serialisiert in). JSON Wenn eine AWS Lambda -Konsole zum Beispiel den Aufruftyp RequestResponse verwendet, zeigt die Konsole den zurückgegebenen Wert an, nachdem die Funktion auf der Konsole abgerufen wurde.

  • Wenn der Handler Objekte zurückgibt, die nicht von json.dumps serialisiert werden können, gibt die Laufzeit einen Fehler zurück.

  • Wenn der Handler None zurückgibt, wie es Python-Funktionen ohne eine return-Anweisung implizit tun, gibt die Laufzeit null zurück.

  • Wenn Sie den Aufruftyp Event (asynchroner Aufruf) verwenden, wird der Wert verworfen.

Anmerkung

In Python 3.9 und späteren Versionen schließt Lambda den requestId Aufruf in die Fehlerantwort ein.

Beispiele

Der folgende Abschnitt zeigt Beispiele für Python-Funktionen, die Sie mit Lambda verwenden können. Wenn Sie die Lambda-Konsole zum Erstellen Ihrer Funktion verwenden, müssen Sie keine ZIP-Archivdatei anhängen, um die Funktionen in diesem Abschnitt auszuführen. Diese Funktionen verwenden Standard-Python-Bibliotheken, die in der von Ihnen ausgewählten Lambda-Laufzeit enthalten sind. Weitere Informationen finden Sie unter Bereitstellungspaket.

Rückgabe einer Nachricht

Das folgende Codebeispiel zeigt eine Funktion namens lambda_handler. Die Funktion akzeptiert Benutzereingaben eines Vor- und Nachnamens und gibt eine Meldung zurück, die Daten aus dem Ereignis enthält, das sie als Eingabe erhalten hat.

def lambda_handler(event, context):
    message = 'Hello {} {}!'.format(event['first_name'], event['last_name'])  
    return { 
        'message' : message
    }

Sie können die folgenden Ereignisdaten verwenden, um die Funktion aufzurufen:

{
    "first_name": "John",
    "last_name": "Smith"
}

Die Antwort zeigt die als Eingabe übergebenen Ereignisdaten an:

{
    "message": "Hello John Smith!"
}

Parsen einer Antwort

Das folgende Codebeispiel zeigt eine Funktion namens lambda_handler. Die Funktion verwendet zur Lambda-Laufzeit übergebene Ereignisdaten. Es analysiert die in der Antwort AWS_REGION zurückgegebene Umgebungsvariable. JSON

import os
import json
        
def lambda_handler(event, context):
    json_region = os.environ['AWS_REGION']
    return {
        "statusCode": 200,
        "headers": {
            "Content-Type": "application/json"
        },
        "body": json.dumps({
            "Region ": json_region
        })
    }

Sie können beliebige Ereignisdaten verwenden, um die Funktion aufzurufen:

{
  "key1": "value1",
  "key2": "value2",
  "key3": "value3"
}

Lambda Laufzeiten setzen mehrere Umgebungsvariablen während der Initialisierung. Weitere Hinweise zu den Umgebungsvariablen, die zur Laufzeit in der Antwort zurückgegeben werden, finden Sie unter Verwenden Sie Lambda-Umgebungsvariablen, um Werte im Code zu konfigurieren.

Die Funktion in diesem Beispiel hängt von einer erfolgreichen Antwort (in200) von API Invoke ab. Weitere Informationen zum API Invoke-Status finden Sie in der Invoke Response-Syntax.

Rückgabe einer Berechnung

Das folgende Codebeispiel zeigt eine Funktion namens lambda_handler. Die Funktion akzeptiert Benutzereingaben und gibt eine Berechnung an den Benutzer zurück. Weitere Informationen zu diesem Beispiel finden Sie im aws-doc-sdk-examples GitHub Repository.

import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event, context):
    ...
    result = None
    action = event.get('action')
    if action == 'increment':
        result = event.get('number', 0) + 1
        logger.info('Calculated result of %s', result)
    else:
        logger.error("%s is not a valid action.", action)

    response = {'result': result}
    return response

Sie können die folgenden Ereignisdaten verwenden, um die Funktion aufzurufen:

{
    "action": "increment",
    "number": 3
}

Bewährte Codemethoden für Python-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 Python könnte das zum Beispiel so aussehen: 

    def lambda_handler(event, context):
    foo = event['foo']
    bar = event['bar']
      
    result = my_lambda_function(foo, bar)

def my_lambda_function(foo, bar):
    // MyLambdaFunction logic here

  • Kontrollieren Sie die Abhängigkeiten im Bereitstellungspaket Ihrer Funktion. Die AWS Lambda Ausführungsumgebung enthält eine Reihe von Bibliotheken. Für die Laufzeiten Node.js und Python gehören dazu die AWS SDKs. 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 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.

  • Nutzen Sie die Wiederverwendung der Ausführungsumgebung zur Verbesserung Ihrer Funktion. Initialisieren Sie SDK Clients und Datenbankverbindungen außerhalb des Funktionshandlers und speichern Sie statische Assets 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.

  • Verwenden Sie Umgebungsvariablen 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 sich die Funktion selbst aufruft oder einen Prozess initiiert, der die Funktion möglicherweise erneut aufruft. Dies kann zu unvorhergesehenen Mengen an Funktionsaufrufen führen und höhere Kosten zur Folge haben. Wenn Sie eine unbeabsichtigte Anzahl von Aufrufen sehen, setzen Sie die für die Funktion reservierte Parallelität auf 0 sofort, um alle Aufrufe der Funktion zu drosseln, während Sie den Code aktualisieren.

  • Verwenden Sie APIs in Ihrem Lambda-Funktionscode nicht undokumentiert, nicht öffentlich. Für AWS Lambda verwaltete Laufzeiten führt Lambda regelmäßig Sicherheits- und Funktionsupdates für interne Lambda-Laufzeiten durch. APIs Diese internen API Updates können abwärtsinkompatibel sein, was zu unbeabsichtigten Folgen wie Aufruffehlern führen kann, wenn Ihre Funktion von diesen nicht öffentlichen Daten abhängig ist. APIs Eine Liste der öffentlich verfügbaren Dateien finden Sie in der API Referenz. APIs

  • 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?.