AWS Lambda
Guia do desenvolvedor

Manipulador de função do AWS Lambda no Go

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().

package main import ( "fmt" "context" "github.com/aws/aws-lambda-go/lambda" ) type MyEvent struct { Name string `json:"name"` } func HandleRequest(ctx context.Context, name MyEvent) (string, error) { return fmt.Sprintf("Hello %s!", name.Name ), nil } func main() { lambda.Start(HandleRequest) }

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 no 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, name MyEvent) (string, error): esta é a assinatura do manipulador do Lambda e inclui o código a ser executado. Além disso, os parâmetros incluídos indicam o seguinte:

    • ctx context.Context: fornece informações do tempo de execução de sua 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 no Go.

    • name MyEvent: Um tipo de entrada com um nome de variável de name cujo valor será retornado na instrução return.

    • string, error: retorna dois valores: string de êxito e informação de erro padrão. Para obter mais informações sobre como manipular erros personalizados, consulte Erros da função do AWS Lambda no Go.

    • return fmt.Sprintf("Hello %s!", name), nil: simplesmente retorna uma saudação "Hello" (Olá) formatada com o nome que você forneceu no evento de entrada. nil indica que não houve erros e que a função foi executada com êxito.

  • func main(): o ponto de entrada que executa o código de sua função do Lambda. Isso é obrigatório.

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

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) { return MyResponse{Message: fmt.Sprintf("%s is %d years old!", event.Name, event.Age)}, nil } func main() { lambda.Start(HandleLambdaEvent) }

A solicitação deverá ser semelhante a esta:

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

E a resposta deverá ser semelhante a esta:

# response { "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 origens 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. Para obter mais informações sobre como implementar informações de manipulação de erros, consulte Erros da função do AWS Lambda no Go.

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)

Uso do 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. Isso significa, por exemplo, que você pode alterar o estado global com segurança, com a garantia de que essas alterações exigirão um novo Contexto de execução e não apresentarão comportamento instável ou bloqueio nas chamadas de função direcionadas para o Contexto de execução anterior. Para obter mais informações, consulte:

package main import ( "log" "github.com/aws/aws-lambda-go/lambda" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/s3" "github.com/aws/aws-sdk-go/aws" ) var invokeCount = 0 var myObjects []*s3.Object func init() { svc := s3.New(session.New()) input := &s3.ListObjectsV2Input{ Bucket: aws.String("examplebucket"), } result, _ := svc.ListObjectsV2(input) myObjects = result.Contents } func LambdaHandler() (int, error) { invokeCount = invokeCount + 1 log.Print(myObjects) return invokeCount, nil } func main() { lambda.Start(LambdaHandler) }

Nesta página: