Controlador de funciones de AWS Lambda en Go

El controlador de la función de Lambda es el método del código de la función que procesa eventos. Cuando se invoca una función, Lambda ejecuta el método del controlador. La función se ejecuta hasta que el controlador devuelve una respuesta, se cierra o se agota el tiempo de espera.

Una función de Lambda escrita en Go se crea como ejecutable de Go. En el código de la función Lambda, debes incluir el aws-lambda-gopaquete github.com/aws/ /lambda, que implementa el modelo de programación Lambda para Go. Además, debe implementar el código de la función de controlador y una función de main().

ejemplo Función de Lambda de Go.

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

Aquí se muestra un ejemplo de entrada para esta función:

{
  "name": "Jane"
}

Tenga en cuenta lo siguiente:

• package main: en Go, el paquete que contiene func main() debe denominarse siempre main.

• import: utilice esta opción para incluir las bibliotecas que requiere la función de Lambda. En este ejemplo, incluye:

  • context: Objeto context AWS Lambda en Go.

  • fmt: objeto de formato de Go que se utiliza para dar formato al valor de retorno de la función.

  • github.com/aws/ aws-lambda-go /lambda: Como se mencionó anteriormente, implementa el modelo de programación Lambda para Go.

• func HandleRequest (ctx context.context, event *MyEvent) (*string, error): es la firma de su controlador Lambda. Es el punto de entrada de la función de Lambda y contiene la lógica que se ejecuta cuando se invoca la función. Además, los parámetros incluidos indican lo siguiente:

  • ctx context.Context: proporciona información en tiempo de ejecución para la invocación de la función de Lambda. ctx es la variable que declara para aprovechar la información disponible a través de Objeto context AWS Lambda en Go.

  • event * MyEvent: se trata de un nombre de parámetro que apunta a. event MyEvent Representa la entrada a la función de Lambda.

  • *string, error: el controlador devuelve dos valores. El primero es un puntero a una cadena que contiene el resultado de la función de Lambda. El segundo es un tipo de error, que es nil si no hay ningún error y contiene información de error estándar si algo sale mal. Para obtener más información sobre el control de errores personalizado, consulte Errores de funciónAWS Lambda en Go.

  • return &message, nil: devuelve dos valores. El primero es un puntero a un mensaje de cadena, que es un saludo creado con el campo Name del evento de entrada. El segundo valor, nil, indica que la función no ha detectado ningún error.

• func main(): el punto de entrada que ejecuta el código de la función de Lambda. Esto es necesario.

  Al agregar lambda.Start(HandleRequest) entre los corchetes del código func main(){}, la función de Lambda se ejecuta. De acuerdo con los estándares del lenguaje Go, el corchete de apertura { debe colocarse directamente al final de la firma de la función main.

Denominación

tiempos de ejecución provided.al2 y provided.al2023

Para las funciones de Go que utilizan el tiempo de ejecución provided.al2 o provided.al2023 en un paquete de implementación .zip, el archivo ejecutable que contiene el código de la función debe tener el nombre bootstrap. Si va a implementar la función de con un archivo .zip, el archivo bootstrap debe estar en la raíz del archivo .zip. Para las funciones de Go que utilizan el tiempo de ejecución provided.al2 o provided.al2023 en una imagen de contenedor, puede utilizar cualquier nombre para el archivo ejecutable.

Puede usar cualquier nombre para el controlador. Para hacer referencia al valor del controlador en su código, puede utilizar la variable de entorno _HANDLER.

Tiempo de ejecución go1.x

Para las funciones de Go que utilizan el tiempo de ejecución go1.x, el archivo ejecutable y el controlador pueden compartir cualquier nombre. Por ejemplo, si establece el valor del controlador como Handler, Lambda llamará a la función main() del archivo ejecutable Handler.

Para cambiar el nombre del controlador de funciones en la consola de Lambda en la que se muestra Runtime settings (Configuración de tiempo de ejecución), seleccione Edit (Editar).

Controlador de funciones de Lambda con tipos estructurados

En el ejemplo anterior, el tipo de entrada era una cadena sencilla. Sin embargo, también pueden pasarse eventos estructurados al controlador de funciones:

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

Aquí se muestra un ejemplo de entrada para esta función:

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

Una respuesta tiene un aspecto similar al siguiente:

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

Para que se exporten, los nombres de campo en la estructura de eventos deben estar en mayúsculas. Para obtener más información sobre cómo gestionar los eventos de AWS las fuentes de aws-lambda-goeventos, consulte /events.

Firmas de controlador válidas

Al crear un controlador de funciones de Lambda en Go tiene varias opciones, pero debe cumplir las reglas siguientes:

• El controlador debe ser una función.

• El controlador puede aceptar entre 0 y 2 argumentos. Si hay dos argumentos, el primero debe implementar context.Context.

• El controlador puede devolver entre 0 y 2 argumentos. Si hay un único valor de retorno, este debe implementar error. Si hay dos valores de retorno, el segundo debe implementar error. Para obtener más información acerca de cómo implementar la información de control de errores, consulte Errores de funciónAWS Lambda en Go.

A continuación se enumeran las firmas de controlador válidas. TIn y TOut representan los tipos compatibles con la biblioteca estándar encoding/json. Para obtener más información, consulte func Unmarshal a fin de saber cómo se deserializan estos tipos.

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

Uso del estado global

Es posible declarar y modificar variables globales que son independientes del código de controlador de la función de Lambda. Además, el controlador puede declarar una función de init que se ejecute cuando este se carga. El comportamiento es el mismo en AWS Lambda que en los programas Go estándar. Una sola instancia de su función de Lambda nunca controlará varios eventos de forma simultánea.

ejemplo Función de Go con variables globales

nota

Este código usa la AWS SDK for Go V2. Para obtener más información, consulte Introducción a 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)
}