Tutorial: Conectar ao MongoDB a partir do AWS Lambda

Verifique os pré-requisitos

Antes de começar, verifique se você tem o seguinte:

• Um cluster do MongoDB Atlas com acesso à rede e funções de usuário configuradas. Se você tiver uma conta da AWS, poderá se inscrever no MongoDB Atlas usando o AWS Marketplace para pagar pelo uso sem compromisso inicial.

• O conjunto de dados de amostra do MongoDB Atlas carregado em seu cluster. Para saber como carregar esses dados de amostra, consulte o guia de Introdução ao MongoDB .

• Uma conta do Amazon Web Services (AWS).

Seu cluster MongoDB Atlas deve permitir o acesso da AWS por meio de uma VPC ou de uma lista de permissões de IP global. O usuário de banco de dados deve ter acesso de leitura aos bancos de dados de amostra.

Criar um projeto Go para o AWS Lambda

Crie um novo projeto Go no seu computador executando os seguintes comandos:

mkdir lambdaexample
cd lambdaexample
go mod init lambdaexample

Estes comandos criam um diretório de projeto e inicializam os módulos Go para suas dependências do AWS Lambda e do MongoDB .

Instale o driver MongoDB Go e o AWS Lambda SDK executando os seguintes comandos:

go get go.mongodb.org/mongo-driver/v2/mongo
go get github.com/aws/aws-lambda-go/lambda

Crie um arquivo denominado main.go no diretório do seu projeto . Este arquivo conterá seu código de função do Lambda.

Adicione o código de conexão MongoDB

Adicione o seguinte código ao seu arquivo main.go:

package main
import (
    "context"
    "os"
    "github.com/aws/aws-lambda-go/lambda"
    "go.mongodb.org/mongo-driver/v2/bson"
    "go.mongodb.org/mongo-driver/v2/bson/primitive"
    "go.mongodb.org/mongo-driver/v2/mongo"
    "go.mongodb.org/mongo-driver/v2/mongo/options"
)
type EventInput struct {
    Limit int64 `json:"limit"`
}
type Movie struct {
    ID    primitive.ObjectID `bson:"_id" json:"_id"`
    Title string             `bson:"title" json:"title"`
    Year  int32              `bson:"year" json:"year"`
}
func HandleRequest(ctx context.Context, input EventInput) ([]Movie, error) {
    if err != nil {
        return nil, err
    }
    collection := client.Database("sample_mflix").Collection("movies")
    opts := options.Find()
    if input.Limit != 0 {
        opts = opts.SetLimit(input.Limit)
    }
    cursor, err := collection.Find(ctx, struct{}{}, opts)
    if err != nil {
        return nil, err
    }
    var movies []Movie
    if err = cursor.All(ctx, &movies); err != nil {
        return nil, err
    }
    return movies, nil
}
func main() {
    client, err = mongo.Connect(options.Client().ApplyURI(os.Getenv("ATLAS_URI")))
    if err != nil {
        return error
    }
    defer func() { _ = client.Disconnect(context.Background) }()
    lambda.Start(func(ctx context.Context, input EventInput) ([]Movie, error) {
        return HandleRequest(ctx context.Context, client, input EventInput)
    })
}

O código anterior define as estruturas de dados EventInput e Movie.

A estrutura EventInput representa a entrada enviada para a função do AWS Lambda. O campo Limit especifica quantos documentos retornar.

A estrutura Movie representa os documentos na collection movies do banco de dados sample_mflix. Possui anotações BSON e JSON em cada campo . A anotação BSON mapeia campos de documento MongoDB para a variável local. A anotação JSON mapeia o campo local para dados que o AWS Lambda pode processar. Você pode incluir quantos campos forem necessários. Somente os campos incluídos são retornados.

O código se conecta ao banco de dados fora das funções HandleRequest e main para garantir que a função estabeleça uma conexão de banco de dados somente quando for iniciada, não toda vez que for executada.

A função HandleRequest faz query da collection sample_mflix.movies e retorna documentos até o limite especificado. Se nenhum limite for fornecido, ele retornará todos os documentos. A função retorna os resultados como JSON.

Construir e pacote a função Lambda

Crie seu projeto para o sistema operacional e a arquitetura que o AWS Lambda exige executando o seguinte comando:

env GOOS=linux GOARCH=amd64 go build

Adicione seu arquivo binário a um arquivo ZIP. O arquivo binário tem o nome lambdaexample, a menos que especificado de outra forma.

Implemente e teste a função

Carregue seu projeto usando o dashboard do AWS Lambda. Confirme que o valor do manipulador está definido como lambdaexample e o valor da arquitetura está definido como x86_64, conforme mostrado na seguinte imagem:

Defina suas variáveis de ambiente no AWS Lambda. Adicione uma variável ATLAS_URI e, em seguida, defina o valor para sua string de conexão do MongoDB Atlas .

Você pode obter sua string de conexão no dashboard do MongoDB Atlas . Para saber mais, consulte o guiaComeçando com Go.

Teste sua função usando a guia Test no painel do AWS Lambda. Forneça um valor limite opcional para o JSON do evento e confirme que a função retorna uma lista de filmes da coleção sample_mflix.movies. Um documento Movie retornado é semelhante a este:

{ "ID": ..., "Title": "The Truman Show", "Year": 1998 }