Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Saiba por que o MongoDB foi selecionado como um líder no 2024 Gartner_Magic Quadrupnt()
Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Produtoschevron-right
Atlaschevron-right

Escreva uma função sem servidor com o AWS Lambda e o MongoDB

Ado Kukic15 min read • Published Jan 28, 2022 • Updated Sep 23, 2022
AtlasJavaScript
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
A forma como escrevemos código, implantamos aplicativos e gerenciamos a escala está em constante mudança e evolução para atender às crescentes demandas de nossos acionistas. No passado, as empresas geralmente implantavam e mantinham sua própria infraestrutura. Nos últimos tempos, todos estão migrando para a nuvem. No entanto, a nuvem é muito nebulosa (heh) e seu significado varia de pessoa para pessoa. Talvez um dia no futuro, os desenvolvedores possam simplesmente escrever o código sem se preocupar com como ou onde ele será implantado e gerenciado.
Esse futuro já chegou e é chamado de computação sem servidor. A computação sem servidor permite que os desenvolvedores se concentrem em escrever código, não em gerenciar servidores. As funções sem servidor permitem ainda que os desenvolvedores dividam seus aplicativos em partes individuais de funcionalidade que podem ser desenvolvidas, implantadas e dimensionadas de forma independente. Essa prática moderna de desenvolvimento de software permite que as equipes criem mais rapidamente, reduzam os custos e limitem o tempo de inatividade.
Nesta publicação no blog, veremos como a computação sem servidor pode nos permitir desenvolver e implantar aplicativos rapidamente. Usaremos o AWS Lambda como nossa plataforma sem servidor e o MongoDB Atlas como nosso provedor de banco de dados.
Vamos começar.
Para acompanhar este tutorial, você precisará do seguinte:
  • Conta MongoDB Atlas (cadastre-se gratuitamente)
  • Node.js 12
O MongoDB Atlas pode ser usado GRÁTIS com um cluster de tamanho 0 M. Implemente o MongoDB em minutos dentro da MongoDB Cloud. Saiba mais sobre o cluster de camada grátis do Atlas aqui.

Minha primeira função sem servidor do AWS Lambda

AWS Lambda é a plataforma de computação sem servidor da Amazon e é uma das principais do setor. Para começar a usar o AWS Lambda, você precisará de uma conta na Amazon Web Services, que poderá ser criada gratuitamente caso ainda não tenha uma.
Página inicial do AWS Lambda
Depois de se inscrever e se conectar ao AWS Management Console, para localizar o serviço AWS Lambda, navegue até o menu principal Serviços e, no campo de pesquisa, digite "Lambda" e selecione "Lambda" no menu suspenso.
Encontre o AWS Lambda
Você será direcionado para o dashboard do AWS Lambda. Se você tiver uma conta nova, não terá nenhuma função e seu dashboard deve ter a seguinte aparência:
Dashboard do AWS Lambda
Estamos prontos para criar nossa primeira função sem servidor com o AWS Lambda. Vamos clicar no botão laranja Criar função para começar.
Nova função do AWS Lambda
Há muitas opções diferentes para escolher ao criar uma nova função sem servidor com o AWS Lambda. Podemos optar por começar do zero ou usar um modelo, que terá um código de exemplo já implementado para nós. Podemos escolher em qual linguagem de programação queremos que nossa função sem servidor seja escrita. Há permissões a considerar. Tudo isso pode ficar excessivo rapidamente, então vamos simplificar.
Manteremos todos os padrões como estão e nomearemos nossa função myFirstFunction. Suas seleções devem ficar assim:
  • Tipo de função: Desenvolver do início
  • Nome da função: myFirstFunction
  • Execução: Node.js 12.x
  • Permissões: Crie uma nova função com permissões básicas do Lambda.
Com essas configurações definidas, pressione o botão laranja Criar função para criar sua primeira função sem servidor do AWS Lambda. Esse processo levará alguns segundos, mas, depois que a função for criada, você verá uma nova tela semelhante a esta:
Dashboard de novas funções do AWS Lambda
Vamos testar nossa função para garantir que ela seja executada. Se rolarmos para baixo até seção Código da função e dermos uma olhada no código atual, ele deverá ter a seguinte aparência:
1exports.handler = async (event) => {
2 // TODO implement
3 const response = {
4 statusCode: 200,
5 body: JSON.stringify('Hello from Lambda!'),
6 };
7 return response;
8};
Vamos pressionar o botão Testar para executar o código e garantir que ele seja executado. Pressionar o botão Testar na primeira vez solicitará que configuremos um evento de teste. Podemos manter todos os padrões aqui, mas precisaremos nomear nosso evento. Vamos nomeá-lo RunFunction e clicar no botão Criar para criar o evento de teste. Agora clique no botão Testar novamente e o editor de código exibirá os resultados da execução da função.
Resultados da execução do AWS Lambda
Recebemos uma resposta bem-sucedida com uma mensagem dizendo "Olá da Lambda!" Vamos fazer uma edição em nossa função. Vamos mudar a mensagem para "Minha primeira função sem servidor!". Depois de fazer essa edição, pressione o botão Salvar e a função sem servidor será implantada novamente. Na próxima vez que você clicar no botão Testar, receberá a mensagem atualizada.
Resultados da função atualizada do AWS Lambda
Isso é ótimo. Estamos escrevendo código Node.js na nuvem e ele é atualizado assim que clicamos no botão de salvar. Embora nossa função não faça muito no momento, nossa função AWS Lambda não está exposta na Internet. Isso significa que a funcionalidade que criamos não pode ser consumida por ninguém. Vamos corrigir isso a seguir.
Usaremos o AWS API Gateway para expor nossa função do AWS Lambda à Internet. Para fazer isso, role até o topo da página e clique no botão Adicionar trigger na seção Designer da página.
AWS Lambda – Adicionar trigger
No menu suspenso de configuração do trigger, selecionaremos Gateway de API (provavelmente será a primeira opção). A partir daqui, selecionaremos Criar uma API e, para o tipo, escolheremos API HTTP. Para saber mais sobre as diferenças entre APIs HTTP e APIs REST, consulte esta página de documentos da AWS. Por motivos de segurança, selecionaremos Abrir, pois a proteção do endpoint da API está fora do escopo deste artigo. Podemos deixar todas as outras opções de lado e apenas clicar no botão Adicionar para criar nosso Gateway de API.
Configuração do gateway de API da AWS
Em alguns segundos, veremos nosso painel Designer atualizado para incluir a API Gateway que criamos. Clicar na API Gateway e abrir os detalhes nos fornecerá informações adicionais, incluindo a URL na qual agora podemos chamar nossa função sem servidor em nosso navegador.
URL do gateway de API
No meu caso, o URL é https://jtcm05iyo6.execute-api.us-east-1.amazonaws.com/default/myFirstFunction. Navegar até este URL exibe a resposta esperada:
Navegador de resposta sem servidor
Observação: se você clicar no URL ativo acima, provavelmente obterá um resultado diferente, pois ele refletirá uma alteração feita posteriormente neste tutorial.
Estamos fazendo um grande progresso. Criamos, implantamos e expusemos uma função sem servidor do AWS Lambda para a Internet. No entanto, nossa função não faz muito. Vamos trabalhar nisso a seguir. Vamos adicionar algumas funcionalidades reais à nossa função sem servidor.
Infelizmente, o editor online no momento não permite que você gerencie dependências ou execute scripts, então teremos que mudar nosso desenvolvimento para nossa máquina local. Para manter as coisas concisas, Faremos nosso desenvolvimento a partir de agora localmente. Quando estivermos satisfeitos com o código, vamos compactá-lo e carregá-lo no AWS Lambda.
Essa é apenas uma maneira de implantar nosso código e, embora não seja necessariamente a mais prática para um caso de uso do mundo real, ela tornará nosso tutorial mais fácil de seguir, pois não precisaremos gerenciar as etapas extras de configuração do AWS CLI ou implantando nosso código no GitHub e usando o GitHub Actions para implantar nossas funções do AWS Lambda. Você deve explorar essas opções ao decidir criar aplicativos reais com frameworks sem servidor, pois elas facilitam muito o dimensionamento de seus aplicativos no longo prazo.
Para configurar nosso ambiente local, criaremos uma nova pasta que usaremos para armazenar nosso código. Crie uma pasta e chame-a myFirstFunction. Nesta pasta, crie dois arquivos: index.js e package.json. Para o arquivo package.json, por enquanto, vamos apenas adicionar o seguinte:
1{
2 "name": "myFirstFunction",
3 "version": "1.0.0",
4 "dependencies": {
5 "faker" : "latest"
6 }
7}
O arquivo package.json nos permitirá listar dependências para nossos aplicativos. Isso é algo que não podemos fazer no momento no editor online. O ecossistema Node.js tem uma infinidade de pacotes que nos permitirão trazer facilmente todos os tipos de funcionalidade para nossos aplicativos. O pacote atual que definimos chama-se faker e vai nos permitir gerar dados fake. Você pode aprender mais sobre faker na página do projeto no GitHub. Para instalar a dependência faker na pasta myFirstFunction, execute npm install. Isso baixará a dependência faker e a armazenará em uma pasta node_modules.
Vamos fazer com que nossa função sem servidor do AWS Lambda sirva uma lista de filmes. No entanto, como não temos acesso a dados reais de filmes, é aqui que entra o faker. Usaremos o faker para gerar dados para nossa função. Abra seu arquivoindex.js e adicione o seguinte código:
1const faker = require("faker");
2
3exports.handler = async (event) => {
4 // TODO implement
5 const movie = {
6 title: faker.lorem.words(),
7 plot: faker.lorem.paragraph(),
8 director: `${faker.name.firstName()} ${faker.name.lastName()}`,
9 image: faker.image.abstract(),
10 };
11 const response = {
12 statusCode: 200,
13 body: JSON.stringify(movie),
14 };
15 return response;
16};
Com a implementação concluída, estamos prontos para carregar esse novo código em nossa função sem servidor do AWS Lambda. Para fazer isso, primeiro precisamos compactar o conteúdo da pasta myFirstFunction. A maneira de fazer isso depende do sistema operacional que você está executando. Para Mac, você pode simplesmente realçar todos os itens na pasta myFirstFunction, clicar com o botão direito do mouse e selecionar Compactar no menu. No Windows, você deve destacar o conteúdo, clicar com o botão direito do mouse e selecionar Enviar para e, em seguida, selecionar Pasta compactada para gerar um único arquivo .zip. No Linux, você pode abrir um shell na pasta myFirstFunction e executar zip aws.zip *.
OBSERVAÇÃO: é muito importante compactar o conteúdo da pasta, não a pasta em si. Caso contrário, você receberá um erro ao fazer upload do arquivo.
Selecione os arquivos, não a pasta inteira
Depois de compactar nossa pasta, é hora de carregá-la. Navegue até a seção Código de função de sua função sem servidor do AWS Lambda e, desta vez, em vez de fazer alterações de código diretamente no editor, clique no botão Ações na seção superior direita e selecione Carregar um arquivo .zip.
Arquivo zip de carregamento do AWS Lambda
Selecione o arquivo compactado que você criou e faça o upload dele. Isso pode levar alguns segundos. Depois que sua função for carregada, você provavelmente verá uma mensagem que diz O pacote de implantação da sua função Lambda "myFirstFunction" é muito grande para permitir a edição de código em linha. No entanto, você ainda pode invocar sua função. Isso é normal. O pacote faker é grande e não o usaremos por muito tempo.
Vamos testar! Vamos testá-lo no painel do AWS Lambda clicando no botão Test na parte superior.
Lambda de teste do AWS Lambda
Estamos tendo um retorno positivo! O texto é só um exemplo, mas é isso que programamos a função para gerar. Toda vez que você pressionar o botão de teste, obterá um conjunto diferente de dados.

Começando a usar o MongoDB Atlas

Gerar dados falsos é válido, mas vamos melhorar e fornecer dados de filmes reais. Para isso, precisaremos acessar um banco de dados que tenha dados reais que possamos usar. O MongoDB Atlas tem vários conjuntos de dados gratuitos que podemos utilizar e um deles é um conjunto de dados de filmes.
Vamos começar configurando nossa conta MongoDB Atlas. Se você ainda não tem uma, cadastre-se aqui.
O MongoDB Atlas pode ser usado de forma GRÁTIS com um cluster de tamanho M0. Implante o MongoDB em minutos no MongoDB Cloud.
Quando você estiver inscrito e conectado ao dashboard do MongoDB Atlas, a primeira coisa que faremos é configurar um novo cluster. Clique no botão Criar um cluster para começar.
Dashboard do MongoDB Atlas
Aqui, selecione a opção Clusters compartilhados, que terá a camada grátis que queremos usar.
Seleção do MongoDB Atlas cluster
Finalmente, para a última seleção, você pode deixar todos os padrões como estão e apenas clicar no botão verde Criar cluster na parte inferior. Dependendo da sua localização, você pode escolher uma região diferente, mas deixarei tudo como está para o tutorial. A criação do cluster levará cerca de um minuto para ser implementada.
Enquanto aguardamos a implantação do cluster, vamos navegar até a aba Acesso ao banco de dados no menu e criar um novo usuário de banco de dados. Vamos precisar de um usuário de banco de dados para nos conectarmos ao nosso MongoDB database. Na página Acesso ao banco de dados, clique no botão Adicionar novo usuário de banco de dados e forneça ao seu usuário um nome de usuário e senha exclusivos. Certifique-se de anotá-los, pois você precisará deles em breve. Certifique-se de que esse usuário de banco de dados possa ler e gravar em qualquer banco de dados, verificando o menu suspenso privilégios de usuário de banco de dados. Ele deve ser selecionado por padrão, mas se não for, certifique-se de que esteja definido como Leitura gravação em qualquer banco de dados.
Usuário de banco de dados do MongoDB Atlas
Em seguida, também queremos configurar o acesso à rede navegando até a aba Acesso à rede no dashboard. Para fins deste tutorial, habilitaremos o acesso ao nosso banco de dados a partir de qualquer IP, desde que a conexão tenha o nome de usuário e a senha corretos. Em um cenário do mundo real, convém limitar o acesso ao banco de dados a IPs específicos nos quais seu aplicativo vive, mas a configuração está fora do escopo deste tutorial.
Acesso à rede MongoDB Atlas
Clique no botão verde Adicionar Endereço IP e, em seguida, no modal que aparece, clique em Permitir acesso de qualquer lugar. Clique no botão verde Confirmar para salvar a alteração.
A esta altura, nosso cluster já deve estar implantado. Vamos selecionar Clusters no menu para ver nosso novo cluster criado e pronto para funcionar. Ele terá a seguinte aparência:
MongoDB Atlas cluster implementado
Uma última coisa que precisaremos fazer é adicionar nossos conjuntos de dados de amostra. Para fazer isso, clique no botão ... em seu cluster e selecione a opção Carregar conjunto de dados de amostra. Confirme no modal que deseja carregar os dados e o conjunto de dados de amostra será carregado.
Conjunto de dados de amostra do MongoDB Atlas
Depois que o conjunto de dados de amostra for carregado, cliquemos no botão Coleções em nosso cluster para ver os dados. Depois que a aba Coleções for carregada, na seção bancos de dados, selecione o banco de dados sample_mflix e a coleção filmes dentro dele. Você verá as informações da coleção na parte superior e os primeiros 20 filmes exibidos à direita. Já temos nosso conjunto de dados!
Conjunto de dados Mflix do MongoDB Atlas
Em seguida, vamos conectar nossos bancos de dados MongoDB implantados no MongoDB Atlas à nossa função AWS Lambda sem servidor.

Conectando o MongoDB Atlas ao AWS Lambda

Temos nosso banco de dados implantado e pronto para ser usado. Tudo o que falta fazer é conectar os dois. Em nosso computador local, vamos abrir o arquivo package.json e adicionar mongodb como uma dependência. Removeremos faker, pois não o usaremos mais em nossos filmes.
1{
2 "name": "myFirstFunction",
3 "version": "1.0.0",
4 "dependencies": {
5 "mongodb": "latest"
6 }
7}
Em seguida, vamos executar npm install para instalar o driver do MongoDB Node.js em nossa pasta node_modules.
Em seguida, vamos abrir o index.js e atualizar nossa função sem servidor do AWS Lambda. Nosso código ficará assim:
1// Import the MongoDB driver
2const MongoClient = require("mongodb").MongoClient;
3
4// Define our connection string. Info on where to get this will be described below. In a real world application you'd want to get this string from a key vault like AWS Key Management, but for brevity, we'll hardcode it in our serverless function here.
5const MONGODB_URI =
6 "mongodb+srv://<USERNAME>:<PASSWORD>@cluster0.cvaeo.mongodb.net/test?retryWrites=true&w=majority";
7
8// Once we connect to the database once, we'll store that connection and reuse it so that we don't have to connect to the database on every request.
9let cachedDb = null;
10
11async function connectToDatabase() {
12 if (cachedDb) {
13 return cachedDb;
14 }
15
16 // Connect to our MongoDB database hosted on MongoDB Atlas
17 const client = await MongoClient.connect(MONGODB_URI);
18
19 // Specify which database we want to use
20 const db = await client.db("sample_mflix");
21
22 cachedDb = db;
23 return db;
24}
25
26exports.handler = async (event, context) => {
27
28 /* By default, the callback waits until the runtime event loop is empty before freezing the process and returning the results to the caller. Setting this property to false requests that AWS Lambda freeze the process soon after the callback is invoked, even if there are events in the event loop. AWS Lambda will freeze the process, any state data, and the events in the event loop. Any remaining events in the event loop are processed when the Lambda function is next invoked, if AWS Lambda chooses to use the frozen process. */
29 context.callbackWaitsForEmptyEventLoop = false;
30
31 // Get an instance of our database
32 const db = await connectToDatabase();
33
34 // Make a MongoDB MQL Query to go into the movies collection and return the first 20 movies.
35 const movies = await db.collection("movies").find({}).limit(20).toArray();
36
37 const response = {
38 statusCode: 200,
39 body: JSON.stringify(movies),
40 };
41
42 return response;
43};
O MONGODB_URI é a sua string de conexão do MongoDB Atlas. Para obter esse valor, vá até o painel do MongoDB Atlas. Na página de visão geral Clusters, clique no botão Conectar.
Cluster de conexão do MongoDB Atlas
A partir daqui, selecione a opção Conectar seu aplicativo e você será levado a uma tela que contém sua string de conexão. Observação: seu nome de usuário será pré-preenchido, mas você terá que atualizar os valores de senha e dbname.
String de conexão do MongoDB Atlas
Depois de fazer as atualizações acima em seu arquivo index.js, salve-o e feche o conteúdo da pasta myFirstFunction novamente. Vamos reimplantar esse código, retornando à nossa função do AWS Lambda e fazendo o upload do novo arquivo zip. Depois de carregado, vamos testá-lo clicando no botão Testar no canto superior direito da página.
Teste de filmes Mflix
Funciona! Obtemos uma lista de vinte filmes do nosso MongoDB database sample_mflix que está implantado no MongoDB Atlas.
Também podemos chamar nossa função diretamente acessando o URL do gateway de API anterior e vendo os resultados no navegador. Navegue até o URL do gateway de API que lhe foi fornecido e você deverá ver o mesmo conjunto de resultados. Se precisar de uma atualização sobre onde encontrá-lo, navegue até a seção Designer da função do AWS Lambda, clique em Gateway de API, clique no botão Detalhes para expandir todas as informações e você verá um URL de endpoint de API, que é onde você pode acessar publicamente esta função sem servidor.
Teste filmes Mflix via gateway de API
A query que escrevemos retorna uma lista de vinte filmes de nossa coleção sample_mflix.movies. Você pode modificar esta query para retornar diferentes tipos de dados facilmente. Como esse arquivo é muito menor, podemos modificá-lo diretamente no navegador usando o editor de código online AWS Lambda. Vamos mudar nossa query para obter uma lista de vinte dos filmes mais bem avaliados e, em vez de recuperar todos os dados de cada filme, apenas obteremos o título, o enredo, a classificação e o elenco do filme. Substitua a query existente que é semelhante a:
1const movies = await db.collection("movies").find({}).limit(20).toArray();
Para:
1const movies = await db.collection("movies").find({},{projection: {title: 1, plot: 1, metacritic: 1, cast:1}}).sort({metacritic: -1}).limit(20).toArray()
Nossos resultados parecerão ligeiramente diferentes agora. O primeiro resultado que obtemos agora é O Mágico de Oz, que tem uma classificação do Metacritic de 100.

Mais uma coisa...

Criamos nossa primeira função sem servidor do AWS Lambda e fizemos algumas modificações nela. A cada iteração, mudamos a funcionalidade do que a função deve fazer, mas, em geral, estabelecemos essa função de recuperação de dados de nosso MongoDB database.
Para encerrar este artigo, vamos criar rapidamente outra função sem servidor, esta para adicionar dados à nossa coleção de filmes. Como já nos tornamos especialistas na seção anterior, isso deve ser muito mais rápido.

Criando uma segunda função do AWS Lambda

Começaremos navegando até a página inicial das funções do AWS Lambda. Aqui, veremos que nossa função existente foi contabilizada. Vamos clicar no botão laranja Criar função para criar uma segunda função sem servidor do AWS Lambda.
Página inicial do AWS Lambda com função
Deixaremos todos os padrões como estão, mas, desta vez, daremos à função um nome mais descritivo. Nós a chamaremos de AddMovie.
Depois que a função for criada, para acelerar as coisas, carregaremos o arquivo .zip da nossa primeira função. Portanto, acesse o menu Ações na seção Código de função, selecione Carregar arquivo zip e escolha o arquivo em sua pasta myFirstFunction.
Para garantir que tudo esteja funcionando bem, vamos criar um evento e executá-lo. Devemos obter uma lista de vinte filmes. Se você receber um erro, verifique se tem o nome de usuário e a senha corretos na string de conexão MONGODB_URI. Você pode notar que os resultados aqui não terão O Mágico de Oz como o primeiro item. Isso é de se esperar, pois fizemos essas edições em nosso editor online myFirstFunction. Até agora, tudo bem.
Em seguida, queremos capturar os dados a serem inseridos em nosso MongoDB database. Para fazer isso, vamos editar nosso caso de teste. Em vez dos valores padrão fornecidos, que não usamos, vamos criar um objeto JSON que pode representar um filme.
Dados de teste dos Vingadores
Agora, vamos atualizar nossa função sem servidor para usar esses dados e armazená-los em nosso banco de dados do MongoDB Atlas na coleção movies do banco de dados sample_mflix. Vamos alterar nossa query do MongoDB find():
1const movies = await db.collection("movies").find({}).limit(20).toArray();
Para um insertOne():
1const result = await db.collection("movies").insertOne(event);
A implementação completa do código é a seguinte:
1const MongoClient = require("mongodb").MongoClient;
2const MONGODB_URI =
3 "mongodb+srv://<USERNAME>:<PASSWORD>@cluster0.cvaeo.mongodb.net/test?retryWrites=true&w=majority";
4
5let cachedDb = null;
6
7async function connectToDatabase() {
8
9 if (cachedDb) {
10 return cachedDb;
11 }
12
13 const client = await MongoClient.connect(MONGODB_URI);
14 const db = await client.db('sample_mflix');
15 cachedDb = db;
16 return db
17}
18
19exports.handler = async (event, context) => {
20 context.callbackWaitsForEmptyEventLoop = false;
21
22 const db = await connectToDatabase();
23
24 // Insert the event object, which is the test data we pass in
25 const result = await db.collection("movies").insertOne(event);
26 const response = {
27 statusCode: 200,
28 body: JSON.stringify(result),
29 };
30
31 return response;
32};
Para verificar se isso funciona, vamos testar nossa função. Ao apertar o botão de teste, obteremos uma resposta semelhante à seguinte imagem:
Operação de inserção bem-sucedida
Isso nos diz que a inserção foi bem-sucedida. Em um aplicativo do mundo real, você provavelmente não gostaria de enviar essa mensagem para o usuário, mas para nossos propósitos ilustrativos aqui, tudo bem. Também podemos confirmar que a inserção foi bem-sucedida entrando em nossa função original e executando-a. Como em nossos dados de teste, definimos a classificação do Metacritic como 101, esse resultado deve ser o primeiro retornado. Vamos verificar.
Após ordem atualizada de inserção
E é só isso. Nosso filme Avengers, que adicionamos com a segunda função sem servidor, agora é retornado como o primeiro resultado porque tem a classificação metacrítica mais alta.

Juntando tudo

Conseguimos! Criamos nossa primeira e segunda funções sem servidor AWS Lambda. Aprendemos como expor nossas funções sem servidor AWS Lambda ao mundo usando Gateway de API da AWS e, finalmente, aprendemos como integrar o MongoDB Atlas em nossas funções sem servidor. Isso é apenas o começo. Fiz algumas observações ao longo do artigo dizendo que o motivo pelo qual estamos fazendo as coisas de uma determinada maneira é para sermos mais concisos, mas se você estiver criando aplicativos do mundo real, quero deixar alguns recursos e leituras adicionais.
Se tiver alguma dúvida ou feedback, acesse os fóruns da MongoDB Community para continuarmos a conversa!

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Artigo

Mapa do Coronavírus e rastreador de dados ao vivo com o MongoDB Charts


Nov 15, 2023 | 3 min read
Artigo

Implantação fácil do MEAN stack com MongoDB Atlas, Cloud Run e HashiCorp Terraform


Jan 30, 2023 | 4 min read
Tutorial

Consulta flexível com Atlas Search


Jul 12, 2024 | 3 min read
Tutorial

Como implementar o Agentic RAG usando o Claude 3.5 Sonnet, LlamaIndex e MongoDB


Jul 02, 2024 | 17 min read
Sumário