Definisci il gestore di funzioni Lambda in Go

Il gestore di funzioni Lambda è il metodo nel codice della funzione che elabora gli eventi. Quando viene richiamata la funzione, Lambda esegue il metodo del gestore. La funzione viene eseguita fino a quando il gestore non restituisce una risposta, termina o scade.

Una funzione Lambda scritta in Go viene creata come eseguibile di Go. Nel codice della funzione Lambda è necessario includere il pacchetto github.com/aws/aws-lambda-go/lambda che implementa il modello di programmazione Lambda per Go. Inoltre, è necessario implementare il codice della funzione del gestore e una funzione main().

Esempio Funzione Go Lambda

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)
}

Di seguito è riportato un input di esempio per questa funzione:

{
  "name": "Jane"
}

Tieni presente quanto segue:

• package main: in Go, il pacchetto contenente func main() deve essere sempre denominato main.

• import: consente di includere le librerie richieste dalla funzione Lambda. In questa istanza, include:

  • context: Oggetto contesto AWS Lambda in Go.

  • fmt: l'oggetto di formattazione di Go utilizzato per formattare il valore restituito della funzione.

  • github.com/aws/aws-lambda-go/lambda: come già accennato, implementa un modello di programmazione Lambda per Go.

• func HandleRequest (ctx context.context, event *MyEvent) (*string, error): Questa è la firma del tuo gestore Lambda. È il punto di ingresso per la funzione Lambda e contiene la logica che viene eseguita quando la funzione viene richiamata. Inoltre, i parametri inclusi indicano quanto segue:

  • ctx context.Context: fornisce le informazioni di runtime relative all'invocazione della funzione Lambda. ctx è la variabile dichiarata per sfruttare le informazioni disponibili mediante Oggetto contesto AWS Lambda in Go.

  • evento* MyEvent: Questo è un parametro denominato che punta a. event MyEvent Rappresenta l'input per la funzione Lambda.

  • *string, error: il gestore restituisce due valori. Il primo è un puntatore a una stringa con il risultato della funzione Lambda. Il secondo è un tipo di errore, vale a dire nil se non si verifica alcun errore e contiene informazioni standard sull'errore se qualcosa va storto.

  • return &message, nil: restituisce due valori. Il primo è un puntatore a un messaggio in formato stringa, che è un saluto costruito utilizzando il campo Name dell'evento di input. Il secondo valore, nil, indica che la funzione non ha riscontrato errori.

• func main(): il punto di ingresso che esegue il codice della funzione Lambda. Questo dato è obbligatorio.

  La funzione Lambda verrà eseguita se si aggiunge lambda.Start(HandleRequest) tra le parentesi del codice func main(){}. Per gli standard del linguaggio Go, la parentesi iniziale, {, deve essere posizionata direttamente alla fine della firma della funzione main.

Denominazione

runtime provided.al2 e provided.al2023

Per le funzioni Go che utilizzano il runtime provided.al2 o provided.al2023 in un pacchetto di implementazione .zip, il file eseguibile che contiene il codice della funzione deve essere denominato bootstrap. Se desideri implementare la funzione con un file .zip, il file bootstrap deve trovarsi nella root di quello .zip. Per le funzioni Go che utilizzano il runtime provided.al2 o provided.al2023 in un'immagine di container, puoi utilizzare qualsiasi nome per il file eseguibile.

Puoi usare qualsiasi nome per il gestore. Per fare riferimento al valore del gestore nel codice, puoi usare la variabile di ambiente _HANDLER.

Runtime go1.x

Per le funzioni Go che utilizzano il runtime go1.x, il file eseguibile e il gestore possono condividere qualsiasi nome. Ad esempio, se imposti il valore del gestore su Handler, Lambda chiamerà la funzione main() nel file eseguibile Handler.

Per modificare il nome del gestore funzioni nella console Lambda, nella scheda Impostazioni runtime, scegliere Modifica.

Gestore della funzione Lambda che utilizza tipi di dato strutturati

Nell'esempio riportato sopra, il tipo di input era una semplice stringa. Tuttavia, è anche possibile passare eventi strutturati al gestore della funzione:

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)
}

Di seguito è riportato un input di esempio per questa funzione:

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

La risposta avrebbe questa struttura:

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

Affinché siano esportati, i nomi dei campi nella struttura dell'evento devono avere l'iniziale maiuscola. Per ulteriori informazioni sulla gestione degli eventi dalle AWS fonti di eventi, consulta aws-lambda-go/events.

Firme del gestore valide

Durante la creazione di un gestore della funzione Lambda in Go sono disponibili diverse opzioni, ma è necessario attenersi alle seguenti regole:

• Il gestore deve essere una funzione.

• Il gestore può richiedere da 0 a 2 argomenti. Nel caso di due argomenti, il primo argomento deve implementare context.Context.

• Il gestore può restituire da 0 a 2 argomenti. Nel caso di un singolo valore restituito, deve implementare error. Nel caso di due valori restituiti, il secondo valore deve implementare error.

Di seguito sono elencate le firme del gestore valide. TIn e TOut rappresentano le tipologie compatibili con la libreria standard encoding/json. Per ulteriori informazioni su come deserializzare queste tipologie, consultare 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)

Utilizzo dello stato globale

È possibile dichiarare e modificare le variabili globali indipendenti dal codice del gestore della funzione Lambda. Inoltre, il gestore può dichiarare una funzione init che viene eseguita quando il gestore viene caricato. Si comporta allo stesso modo dei programmi Go standard. AWS Lambda Una singola istanza della funzione Lambda non gestirà mai più eventi simultaneamente.

Esempio Funzione Go con variabili globali

Nota

Questo codice utilizza la AWS SDK for Go V2. Per ulteriori informazioni, vedere Guida introduttiva alla 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 := "DOC-EXAMPLE-BUCKET"
	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)
}