Benennung Lambda-Funktions-Handler mit strukturierten Typen Verwenden des globalen Zustands

AWS Lambda-Funktions-Handler in Go

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.

Eine Lambda-Funktion in Go wird als ausführbare Go-Datei erstellt. In Ihren Lambda-Funktionscode müssen Sie das Paket github.com/aws/aws-lambda-go/lambda einfügen, das das Lambda-Programmiermodell für Go implementiert. Darüber hinaus müssen Sie Handler-Funktionscode und eine main()-Funktion implementieren.

Beispiel Go-Lambda-Funktion


package main

import (
	"context"
	"fmt"
	"github.com/aws/aws-lambda-go/lambda"
)

type MyEvent struct {
	Name string `json:"name"`
}

func HandleRequest(ctx context.Context, event *MyEvent) (*string, error) {
	if event == nil {
		return nil, fmt.Errorf("received nil event")
	}
	message := fmt.Sprintf("Hello %s!", event.Name)
	return &message, nil
}

func main() {
	lambda.Start(HandleRequest)
}

Hier ist eine Beispieleingabe für diese Funktion:


{
  "name": "Jane"
}

Beachten Sie Folgendes:

Paket „main“: In Go muss das Paket mit func main() stets den Namen main haben.
Importieren: Damit können Sie die Bibliotheken einschließen, die Ihre Lambda-Funktion erfordert. In diesem Fall sind dies:
- context: AWS Lambda-Context-Objekt in Go.
- Fmt: Das Formatierungs-Objekt in Go, das zur Formatierung des Rückgabewerts Ihrer Funktion verwendet wird.
- github.com/aws/aws-lambda-go/lambda: Wie bereits erwähnt, implementiert das Lambda-Programmiermodell für Go.
func HandleRequest(ctx context.Context, event *MyEvent) (*string, error): Dies ist die Signatur Ihres Lambda-Handlers. Es ist der Einstiegspunkt für Ihre Lambda-Funktion und enthält die Logik, die ausgeführt wird, wenn Ihre Funktion aufgerufen wird. Darüber hinaus geben die enthalten Parameter Folgendes an:
- ctx context.Context: Stellt Laufzeitinformationen für Ihren Lambda-Funktionsaufruf bereit. ctx ist die Variable, die Sie deklarieren, um die verfügbaren Informationen über AWS Lambda-Context-Objekt in Go zu nutzen.
- event *MyEvent: Dies ist ein Parameter mit dem Namen event, der auf verweistMyEvent. Es stellt die Eingabe für die Lambda-Funktion dar.
- *string, error: Der Handler gibt zwei Werte zurück. Der erste ist ein Zeiger auf eine Zeichenfolge, die das Ergebnis der Lambda-Funktion enthält. Der zweite ist ein Fehlertyp, der nil ist, wenn kein Fehler vorliegt, und der standardmäßige Fehlerinformationen enthält, falls etwas schief geht. Weitere Informationen zur benutzerdefinierten Fehlerbehandlung finden Sie unter AWS Lambda-Funktionsfehler in Go.
- return &message, nil: Gibt zwei Werte zurück. Der erste ist ein Zeiger auf eine Zeichenfolgennachricht, bei der es sich um eine Begrüßung handelt, die anhand des Name-Felds aus dem Eingabeereignis erstellt wurde. Der zweite Wert, nil, gibt an, dass bei der Funktion keine Fehler aufgetreten sind.
func main(): Der Eintrittspunkt, von dem aus Ihr Lambda-Funktionscode ausgeführt wird. Diese Information ist erforderlich.

Indem Sie lambda.Start(HandleRequest) zwischen den func main(){}-Code-Klammern hinzufügen, wird Ihre Lambda-Funktion ausgeführt. Laut den Standards der Go-Sprache muss sich die offene Klammer { direkt am Ende der main-Funktionssignatur befinden.

Benennung

provided.al2 and provided.al2023 Laufzeiten

Bei Go-Funktionen, die die Laufzeit provided.al2 oder provided.al2023 in einem ZIP-Bereitstellungspaket verwenden, muss die ausführbare Datei, die Ihren Funktionscode enthält, bootstrap heißen. Wenn Sie eine Funktion über eine ZIP-Datei bereitstellen, muss sich die bootstrap-Datei im Stammverzeichnis der ZIP-Datei befinden. Bei Go-Funktionen, die die Laufzeit provided.al2 oder provided.al2023 in einem Container-Image verwenden, kann die ausführbare Datei einen beliebigen Namen haben.

Für den Handler kann ein beliebiger Name verwendet werden. Sie können die Umgebungsvariable _HANDLER verwenden, um in Ihrem Code auf den Handler-Wert zu verweisen.

Laufzeit „go1.x“

Bei Go-Funktionen, die die Laufzeit go1.x verwenden, können sich die ausführbare Datei und der Handler einen beliebigen Namen teilen. Wenn Sie beispielsweise den Wert des Handlers auf Handler setzen, ruft Lambda die Funktion main() in der ausführbaren Datei Handler auf.

Um den Namen des Funktionshandlers in der Lambda-Konsole zu ändern, wählen Sie im Bereich Laufzeiteinstellungen die Option Bearbeiten.

Lambda-Funktions-Handler mit strukturierten Typen

Im obigen Beispiel handelte es sich beim Eingabetyp um eine einfache Zeichenfolge. Sie können jedoch auch strukturierte Ereignisse an Ihren Funktions-Handler übergeben:


package main

import (
	"fmt"
	"github.com/aws/aws-lambda-go/lambda"
)

type MyEvent struct {
	Name string `json:"What is your name?"`
	Age  int    `json:"How old are you?"`
}

type MyResponse struct {
	Message string `json:"Answer"`
}

func HandleLambdaEvent(event *MyEvent) (*MyResponse, error) {
	if event == nil {
		return nil, fmt.Errorf("received nil event")
	}
	return &MyResponse{Message: fmt.Sprintf("%s is %d years old!", event.Name, event.Age)}, nil
}

func main() {
	lambda.Start(HandleLambdaEvent)
}

Hier ist eine Beispieleingabe für diese Funktion:


{
    "What is your name?": "Jim",
    "How old are you?": 33
}

Die Antwort schaut wie folgt aus:


{
    "Answer": "Jim is 33 years old!"
}

Um exportiert werden, müssen Feldnamen in der Ereignisstruktur großgeschrieben werden. Weitere Informationen zur Behandlung von Ereignissen aus AWS Ereignisquellen finden Sie unter aws-lambda-go/events .

Gültige Handler-Signaturen

Sie haben bei der Erstellung eines Lambda-Funktions-Handlers in Go mehrere Möglichkeiten. Allerdings müssen die folgenden Regeln beachten:

Der Handler muss eine Funktion sein.
Der Handler kann zwischen 0 und 2 Argumente aufnehmen. Bei zwei Argumenten muss das erste Argument implementiere context.Context.
Der Handler kann zwischen 0 und 2 Argumente zurückgeben. Bei einem einzigen Rückgabewert muss er implementiere error. Bei zwei Rückgabewerten muss der zweite Wert implementiere error. Weitere Informationen zur Implementierung von Informationen zur Fehlerbehandlung finden Sie unter AWS Lambda-Funktionsfehler in Go.

Im Folgenden werden gültige Handler-Signaturen aufgeführt. TIn und TOut stellen Typen dar, die mit der Standardbibliothek encoding/json kompatibel sind. Weitere Informationen zur Deserialisierung dieser Typen finden Sie unter func Unmarshal.

```
func ()
```
```
func () error
```
```
func (TIn) error
```
```
func () (TOut, error)
```
```
func (context.Context) error
```
```
func (context.Context, TIn) error
```
```
func (context.Context) (TOut, error)
```

func (context.Context, TIn) (TOut, error)

Verwenden des globalen Zustands

Sie können globale Variablen deklarieren und ändern, die vom Handler-Code Ihrer Lambda-Funktion unabhängig sind. Darüber hinaus deklariert Ihr Handler möglicherweise eine init-Funktion, die ausgeführt wird, wenn Ihr Handler geladen wird. Dies verhält sich in AWS Lambda wie in Standard-Go-Programmen. Eine einzelne Instance Ihrer Lambda-Funktion behandelt nie mehrere Ereignisse gleichzeitig.

Beispiel Go-Funktion mit globalen Variablen

Anmerkung

Dieser Code verwendet die AWS SDK for Go-V2. Weitere Informationen finden Sie unter Erste Schritte mit AWS SDK for Go-V2.


package main

import (
	"context"
	"github.com/aws/aws-lambda-go/lambda"
	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/service/s3/types"
	"log"
)

var invokeCount int
var myObjects []types.Object

func init() {
	// Load the SDK configuration
	cfg, err := config.LoadDefaultConfig(context.TODO())
	if err != nil {
		log.Fatalf("Unable to load SDK config: %v", err)
	}

	// Initialize an S3 client
	svc := s3.NewFromConfig(cfg)

	// Define the bucket name as a variable so we can take its address
	bucketName := "examplebucket"
	input := &s3.ListObjectsV2Input{
		Bucket: &bucketName,
	}

	// List objects in the bucket
	result, err := svc.ListObjectsV2(context.TODO(), input)
	if err != nil {
		log.Fatalf("Failed to list objects: %v", err)
	}
	myObjects = result.Contents
}

func LambdaHandler(ctx context.Context) (int, error) {
	invokeCount++
	for i, obj := range myObjects {
		log.Printf("object[%d] size: %d key: %s", i, obj.Size, *obj.Key)
	}
	return invokeCount, nil
}

func main() {
	lambda.Start(LambdaHandler)
}

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Erstellen mit Go

Context