Como construir uma API poderosa com Node.js, Serverless e Lambda

❤️

Esse artigo é assim como serverless, sem enrolação, apenas focando no que é mais importante!

Antes precisamos conhecer nossas dependências e o que precisaremos para iniciar nosso projeto:

• NodeJS (12.18.3)
• Yarn (1.22.5)
• AWS Client devidamente instalado e configurado

Primeiramente iremos rodar o seguinte comando instalando algumas dependências:

yarn add serverless serverless-offline -D

Após a instalação iremos criar um novo arquivo handler.js e nele colocaremos o seguinte código:

Código de nossa primeira Lambda

Também iremos adicionar um arquivo chamado serverless.yml e nele o seguinte conteúdo:

Devemos ter bastante atenção ao realizar alterações em arquivos yaml pois a identação errada pode quebrar o build :D

Agora vamos entender o que esse arquivo faz:

• Primeiramente damos o nome ao serviço (Linha 2)
• Também informamos onde esse arquivo estará rodando e qual o runtime

Package:

• A opção excludeDevDependencies indica se o serverless deve automaticamente excluir as dependências de desenvolvimento.
• A opção individually habilita fazer o empacotamento por cada função. Caso verdadeiro deveremos informar um package para cada função.

Plugins:

Antes de continuarmos precisamos fazer um adendo, o serverless nada mais é do que um grupo de plugins que fazem parte do core do produto. Sendo assim os plugins nada mais são do que códigos JavaScript que adicionam ou estendem comandos dentro do serverless. Caso queira aprofundar um pouco mais recomendo a leitura da documentação.

• Estaremos inserindo o plugin serverless-offline para que possamos fazer todos os processos que o serverless executa para deploy mas local.
  (Spoiler: Na parte 2 iremos utilizar o localstack para simular todo o ambiente aws)

Functions:

• Dentro de functions informamos primeiramente o nome da nossa primeira function hello
• handler basicamente este apontamento indica onde está o código que será executado.
• events o evento que irá realizar o trigger dessa lambda. Podendo ser por exemplo um upload de arquivo para o S3, um Stream do Kinesis, um stream do DynamoDB. No nosso caso estaremos utilizando um Api Gateway (Request HTTP) onde definimos o path da request e o method que poderia ser put, get, post. Nesse caso vamos utilizar any.

Caso tenha mais interesse em aprofundar o conhecimento nesse arquivo a documentação é bem completa

Serverless Framework - AWS Lambda Guide - Serverless.yml Reference

Rodando nossa API

Para executarmos nossa api será necessário executar o comando sls offline no diretório em que se encontrar o arquivo serverless.yml e deve-se ter um resultado parecido com o seguinte:

Resultado do framework serverless-offline

Ao acesso a rota que a CLI nos informa (http://localhost:3000/dev/hi) teremos o seguinte resultado:

Result da nossa primeira lambda

Mas antes temos alguns poréns:

• Ainda nao conseguimos utilizar ES6.
• Caso seja necessário rodar mais de um serviço ao mesmo tempo teremos o problema de portas, pois estariam tentando utilizar a mesma porta.
• Podemos melhorar um pouco nossa estrutura de arquivos.

Utilizando ES6

Para que possamos transpilar nosso código ES6 corretamente utilizaremos o babel e webpack. Para começarmos devemos instalar as seguintes dependências no nosso projeto:

yarn add @babel/core @babel/preset-env babel-loader babel-plugin-source-map-support serverless-webpack webpack webpack-node-externals -D

Também vamos melhorar nossa estrutura de arquivos, preparando para que possamos ter vários serviços dentro do mesmo repositório. Devemos criar uma nova pasta chamada services e dentro dela uma sub-pasta chamada service-1 ficando assim nossa estrutura até o momento:

└── services
    └── service-1
        ├── handler.js
        ├── package.json
        ├── serverless.yml
        └── yarn.lock

Dentro do diretório services/service-1 Criaremos um arquivo webpack.config.js com o seguinte conteúdo:

Também vamos adicionar um arquivo .babelrc com o seguinte conteúdo:

Vamos fazer uma pequena alteração em nosso arquivo serverless.yml e nele adicionaremos o plugin serverless.yml serverless-webpack ficando da seguinte maneira:

Vamos criar um novo diretório dentro da raiz do nosso projeto chamado helpers e dentro dele vamos criar um novo arquivo chamado response.js

Sem mágica até então. Estamos apenas criando algo para evitar duplicidade de código

Faremos também uma alteração dentro do nosso arquivo handler.js em que vamos utilizar nosso novo helper e estaremos utilizando nossa constante de maneira assíncrona:

Nossa estrutura até o momento é a seguinte:

├── helpers
 └── response.js
└── services
    └── service-1
        ├── handler.js
        ├── package.json
        ├── serverless.yml
        ├── webpack.config.js
        └── yarn.lock

Vamos executar o comando sls offline dentro do diretório services/service-1 :

Já percebemos algumas diferenças

Pudemos perceber algumas diferenças:

• Pudemos perceber que o Webpack está funcionando corretamente, realizando todo o processo de transpilação do nosso código.
• Podemos perceber também que ele utilizou o nosso helper durante a geração do novo código (Que caso queira verificar a estrutura ficara dentro da pasta .webpack)
• Basicamente a partir de agora nossa api possui a inteligência necessária para distinguir, compilar e enviar para a lambda somente o que é realmente necessário, seja de um pacote, serviço ou até uma dependência.

Acessando o link informado dentro do navegador deveremos ter o seguinte resultado:

EUREKA!

Terminamos aqui nosso primeiro capítulo. No próximo daremos continuidade com os seguinte temas:

• Melhoraremos nossa estrutura de arquivos.
• Rodar múltiplas lambdas locais.
• Deploy para AWS .
• Utilização do localstack para um ambiente fiel a AWS.

Enquanto isso deixo aqui alguns outros posts para que você conheça melhor nossa stack, os motivos e acima de tudo os aprendizados:

Esse em que o João Costa, co-founder da Kovi destrincha os principais motivos das stacks que utilizamos:

Node, Serverless, Elixir: a stack da Kovi

Esse em que o Junior Ferreira, Tech Lead da um panorama após utilizarmos serverless em produção por um ano e os principais aprendizados:

Serverless após um ano em produção

Grande Abraço