Nomenclatura Manipulador de função do Lambda usando tipos estruturados Usar o estado global

Definir o manipulador de função do Lambda em Go

O manipulador da função do Lambda é o método no código da função que processa eventos. Quando sua função é invocada, o Lambda executa o método do manipulador. A função é executada até que o manipulador retorne uma resposta, seja encerrado ou atinja o tempo limite.

Uma função do Lambda escrita em Go é criada como um executável do Go. No código da função do Lambda, você precisa incluir o pacote github.com/aws/aws-lambda-go/lambda que implementa o modelo de programação do Lambda para Go. Além disso, você precisa implementar o código da função do manipulador e uma função main().

exemplo Função do Lambda em 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)
}

Um exemplo de entrada para esta função é:


{
  "name": "Jane"
}

Observe o seguinte:

pacote main: no Go, o pacote que contém func main() sempre deve ser denominado main.
import: use essa opção para incluir as bibliotecas necessárias para a função do Lambda. Neste caso, ela inclui:
- context: Objeto de contexto do AWS Lambda em Go.
- fmt: o objeto de Formatação do Go usado para formatar o valor de retorno da função.
- github.com/aws/aws-lambda-go/lambda: conforme mencionado anteriormente, implementa o modelo de programação do Lambda para Go.
func HandleRequest(ctx context.Context, event *MyEvent) (*string, error): esta é a assinatura do manipulador do Lambda. É o ponto de entrada para sua função do Lambda e contém a lógica que é executada quando sua função é invocada. Além disso, os parâmetros incluídos indicam o seguinte:
- ctx context.Context: fornece informações do runtime da invocação da função do Lambda. ctx é a variável que você declara para utilizar as informações disponíveis por meio do Objeto de contexto do AWS Lambda em Go.
- event *MyEvent: um parâmetro chamado event que aponta para MyEvent. Ela representa a entrada para a função do Lambda.
- *string, error: o manipulador retorna dois valores. O primeiro é um ponteiro para uma string que contém o resultado da função do Lambda. O segundo é um tipo de erro, que é nil quando não há erro e contém informações de erro padrão se algo errado ocorre.
- return &message, nil: retorna dois valores. O primeiro é um ponteiro para uma mensagem de string que consiste em uma saudação construída usando o campo Name do evento de entrada. O segundo valor, nil, indica que a função não encontrou nenhum erro.
func main(): o ponto de entrada que executa o código da função do Lambda. Isso é obrigatório.

Com a adição de lambda.Start(HandleRequest) entre colchetes do código func main(){}, a função do Lambda será executada. De acordo com os padrões da linguagem Go, o colchete de abertura, { deve ser colocado diretamente no final da assinatura da função main.

Nomenclatura

Runtimes provided.al2 e provided.al2023

Para funções Go que usam o runtime provided.al2 ou provided.al2023 em um pacote de implantação .zip, o arquivo executável que contém o código da função deve ser denominado bootstrap. Se você estiver implantando a função com um arquivo .zip, o arquivo bootstrap deverá estar na raiz do arquivo .zip. Para funções Go que usam o runtime provided.al2 ouprovided.al2023 em uma imagem de contêiner, você pode usar qualquer nome para o arquivo executável.

Você pode usar qualquer nome para o manipulador. Para referenciar o valor do manipulador em seu código, você pode usar a variável de ambiente _HANDLER.

runtime do go1.x

Para funções Go que usam o runtime go1.x, o arquivo executável e o manipulador podem compartilhar qualquer nome. Por exemplo, se você definir o valor do manipulador como Handler, o Lambda chamará a função main() no arquivo executável Handler.

Para alterar o nome do manipulador de função no console do Lambda no painel de Configurações de runtime, escolha Editar.

Manipulador de função do Lambda usando tipos estruturados

No exemplo acima, o tipo de entrada era uma sequência simples. Mas você também pode passar eventos estruturados para o manipulador da função:


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

Um exemplo de entrada para esta função é:


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

A resposta é semelhante a:


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

Para serem exportados, os nomes do campo no struct do evento devem estar em letra maiúscula. Para obter mais informações sobre a manipulação de eventos de fontes de eventos da AWS, consulte aws-lambda-go/events.

Assinaturas válidas de manipulador

Há várias opções ao criar um manipulador de função do Lambda no Go, mas você deve observar as seguintes regras:

O manipulador deve ser uma função.
O manipulador pode usar de 0 a 2 argumentos. Se houver dois argumentos, o primeiro argumento deverá implementar context.Context.
O manipulador pode retornar de 0 a 2 argumentos. Se houver um único valor de retorno, ele deverá implementar error. Se houver dois valores de retorno, o segundo valor deverá implementar error.

As assinaturas válidas de manipulador são listadas a seguir. TIn e TOut representam tipos compatíveis com a biblioteca encoding/json padrão. Para obter mais informações, consulte func Unmarshal para saber como esses tipos são desserializados.

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

Usar o estado global

Você pode declarar e modificar variáveis globais que são independentes do código do manipulador da função do Lambda. Além disso, o manipulador pode declarar uma função init que é executada quando o manipulador é carregado. Esse comportamento é o mesmo no AWS Lambda e nos programas Go padrão. Uma única instância de sua função do Lambda nunca manipulará vários eventos simultaneamente.

exemplo Função Go com variáveis globais

nota

Esse código usa o AWS SDK for Go V2. Para obter mais informações, consulte Conceitos básicos do 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)
}

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Construção com Go

Contexto