Criando uma AWS lambda com Serverless framework
Tags: aws, node, serverless, braziliandevs
Published: 2022-04-20 00:54:40

## O que são AWS Lambda?

As lambda da AWS são funções orientadas a eventos por exemplo: você pode executar a função através de uma requisição HTTP, você pode executar ela através de outros serviços da AWS como S3 Bucket, existem várias maneiras de executar essas funções.

A Lambda é executada sem servidor que quer dizer que você não precisa gerenciar a infraestrutura de servidores e você só vai pagar por cada execução da função que pode reduz custos.

## O que é serverless framework?

Serverless Framework é uma forma de facilitar a criação de ambientes serverless como: construir APIs, configurar toda a parte de politicas e permissões, provisionar ambientes diferentes para cada etapa do desenvolvimento, configurar e adicionar outros serviços da AWS, fazer deploy mais automatizados.

## Pré-requisitos

Antes de começar você precisa ter uma conta na [AWS](https://aws.amazon.com/pt/), eles possuem serviços gratuitos mas no momento do cadastro eles pedem seu cartão de crédito só para verificação, mas sempre fique atento aos custos dos serviços que você está utilizando para não exceder o limite gratuito.

Você precisa baixar a [CLI](https://aws.amazon.com/pt/cli/) da AWS e para configurar o login da CLI você pode seguir esse [Tutorial CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-prereqs.html) da própria AWS para criar um perfil administrador em sua conta na AWS para ter acesso aos serviços AWS no terminal e por fim no terminal você pode executar o [Comando](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html) `aws configure` que vai te pedir algumas informações referente ao perfil que você criou na AWS.

Por último tenha instalado na sua máquina o [nodejs(estou utilizando a versão 16.14.0)](https://nodejs.org/en/) e [serverless framework(estou utilizando a versão 3.14.0)](https://www.serverless.com/framework/docs/getting-started).

## Criando a estrutura do projeto

Para criar o projeto abra o terminal e execute o comando abaixo:
```shell
serverless create --template aws-nodejs --path petzinho
```
Esse comando cria um projeto serverless utilizando o template da AWS para Nodejs e o —path é o nome da aplicação no meu caso o nome é **petzinho.**

Abrindo o projeto no seu editor você irá encontrar uma estrutura assim:

- .gitignore: são arquivos e pastas que não vão ser enviados para o github
- handler.js: é uma função já criada pelo serverless
- serverless.yml: aonde fica toda a configuração da AWS

No arquivo serverless.yml ele tem essa estrutura:

```yml
service: petzinho # nome do serviço

frameworkVersion: '3' # versão do framework

provider:
  name: aws # nome do provedor poderia ser azure ou google
  runtime: nodejs12.x # versão do nodejs

functions: # as funções lambda
  hello: # nome da função
    handler: handler.hello # aonde está o arquivo que será executado
```

Na linha handler.hello o **handler** é o nome do arquivo e o **hello** é a função dentro do arquivo que será executada. Vamos dar uma ajustada nesses arquivos a seguir.

Podem deletar o arquivo **handler.js**(iremos criar o arquivo em outro local), crie uma pasta **utils** na raiz do projeto e dentro dela crie um arquivo **pets.json** com esse conteúdo que vai servir como dados para nossa API consumir: [pets.json](https://raw.githubusercontent.com/janapc/exemplo-lambda/master/utils/pets.json).Crie uma pasta **functions** na raiz do projeto e essa pasta irá conter nossas funções, dentro da pasta functions crie um arquivo listarPets.js nesse arquivo vamos criar uma função:

```javascript
"use strict";

const pets = require("../utils/pets.json");

module.exports.handler = async (event) => {
  try {
    const result = pets.data;

    return {
      statusCode: 200,
      body: JSON.stringify(
        {
          pets: result,
        }
      ),
    };
  } catch (error) {
    return {
      statusCode: 500,
      body: JSON.stringify(
        {
          error: error.message,
        }
			),
    };
  }
};
```

Toda função recebe um **event** esse event possui algumas informações como body da requisição, headers e etc.

No código acima pegamos os dados dos pets cadastrados e atribuímos a uma variável **result** no retorno da função usamos um padrão que o próprio serverless, nele passamos o statusCode que é status de retorno da nossa aplicação, existem vários status que podem ser usados em diferentes ocasiões, no **body** enviamos uma resposta para o usuário pode ser uma mensagem ou objeto e caso aconteça algum erro na nossa API o erro irá cair no catch aonde retornamos o erro formatado para o usuário.

No arquivo **serverless.yml** vamos implementar a nova função que criamos agora pouco. Na parte das **functions** colocamos:

```yml
functions: # as funções lambda
  listarPets: # nome da função
    handler: functions/listarPets.handler # aonde está o arquivo que será executado
    events:
      - http:
          path: listarPets # nome da nossa rota
          method: get # metodo HTTP
```

## Rodando localmente

Com nossa rota criada vamos rodar ela localmente e para isso precisamos de um plugin do serverless framework. O plugin que vamos utilizar é [serverless-offline](https://www.serverless.com/plugins/serverless-offline), para instalar ele é super simples. Dentro da pasta do seu projeto vamos inicializar o **Nodejs** com **npm:**

```shell
npm init -y
```

Vamos instalar o serverless-offline:

```shell
npm install serverless-offline --save-dev
```

Vamos incluir o plugin no arquivo serverless.yml:

```yml
plugins: # lista de plugin
  - serverless-offline # rodar o projeto na sua maquina offline
```

no arquivo **package.json** você pode incluir um script para rodar a API localmente:

```JSON
"scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "sls offline start"
}
```

no terminal você pode rodar o comando:
```shell
npm run start
```

Pronto sua aplicação vai estar rodando localmente na porta **3000** e para testar você pode utilizar o Postman, curl ou Insomnia, o resultado final será esse:

![Postman aberto com a rota  http://localhost:3000/dev/listarPets e o resultado é uma lista de pets com informações sobre id, raça e descrição](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/518gcc9xic0q7ftdtbr2.png)

## Deploy para AWS:

O deploy para AWS é feito através de um comando, para isso colocaremos mais um script em nosso **package.json** para subir em ambiente de desenvolvimento ou você pode escolher qual ambiente subir:

```JSON
"deploy:dev": "sls deploy --stage dev"
```

Lembrando que cada serviço da AWS tem custo e tem uma parte gratuita fique sempre atento a isso.

Para subir para AWS executamos o comando no terminal:

```
npm run deploy:dev
```

Demora um pouco para terminar de executar porque ele cria toda a estrutura e tudo que precisa para nossa API funcionar, você pode acompanhar o andamento no **cloudformation** dentro do console da AWS, no final da execução ele mostra um **endpoint** acessando esse endpoint no curl, postman ou insomnia teremos o mesmo resultado que tivemos rodando localmente.

Para deletar tudo que subimos você pode esvaziar o s3 bucket que foi criado e depois deletar o cloudformation com isso ele vai deletar tudo relacionado a API que a gente subiu.

## Final
O projeto final está [exemplo-lambda](https://github.com/janapc/exemplo-lambda).

Essa foi apenas uma introdução as lambdas da AWS, existem muitas coisas que podemos fazer e utilizar da melhor forma em cada projeto.

Espero ter ajudado de alguma forma e muito obrigado por ler 💜.