Serverless básico
Tags: serverless, faas, node, ptbr
Published: 2021-09-23 16:59:24

Serverless é uma arquitetura baseada em funções como um serviço (FaaS - *Function as a Service*), o principal objetivo é que o desenvolvedor se preocupe apenas com o código da função (lógica do negócio) e a responsabilidade pela configuração do ambiente/máquina que vai rodar o código fique por conta do provedor de cloud.

# Características

- **Ambiente sem estado para rodar o código**, cada evento que aciona a função **PODE** ser processado em um ambiente completamente novo, isso limita por exemplo a utilização do sistema de arquivos do ambiente onde o código está rodando e um novo processamento está desacoplado dos processamentos anteriores.
- **Tempo de execução limitado**, o processamento deve ocorrer dentro de um período de tempo, se a execução não estiver completa o ambiente onde o código está rodando simplesmente morre.
- **Orientado a eventos**, cada função de uma aplicação serverless tem um ou mais gatilhos que acionam a execução do código.

# Código básico com o framework Serverless

```yaml
# serverless.yml
provider:
  name: aws
  runtime: nodejs14.x
  memorySize: 512
  timeout: 3

functions:
  users:
    handler: ./UserHandler.handler
    events:
      - http:
          method: GET
          path: users
          cors: true
```

```javascript
// UserHandler.js
// aws sample
exports.handler =  async function(_event, _context) {
    const service = new UserService();
    const response = await service.findAll();
    return JSON.stringify(response);
}
```

Com o comando abaixo é possível realizar a implantação da função no provedor de cloud.

```bash
npx serverless deploy
```

Quando uma requisição chegar na rota registrada no API Gateway um novo evento será disparado e este evento pode ser processado por uma função nova (*cold*) ou por uma função ativa (*warm*).

![serverless_article](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fj4vtqmoohx8k2bbn7fa.png)
 

# Diferenças entre serverless e uma arquitetura cloud com contêineres

- Uma grande diferença é que o serverless te força a quebrar suas operações e definir muito bem qual a responsabilidade da função. Isso é imposto basicamente pelo tempo limite de execução e pelos valores maiores cobrados para execuções com tempo maior ou com consumo de memória maior.
- As funções serverless ficam desativadas quando não existem eventos para processar, diferentemente de um contêiner rodando uma aplicação que fica 100% do tempo rodando mesmo sem requisições.

# Principais ferramentas

- Serverless framework.
- AWS Lambda.
- Azure Functions.
- Google Cloud Functions.
- Infraestrutura como código.

# Referencias

- [Artigo da Red Hat sobre Serverless](https://www.redhat.com/pt-br/topics/cloud-native-apps/what-is-serverless).
- [Artigo da AWS sobre Lambda](https://docs.aws.amazon.com/whitepapers/latest/serverless-architectures-lambda/serverless-architectures-lambda.pdf#welcome).
- [Exemplo de código com AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-handler.html).
- [Exemplo de código com Azure Functions](https://docs.microsoft.com/pt-br/azure/developer/javascript/how-to/develop-serverless-apps).
- [Exemplo de código com Google Cloud Functions](https://cloud.google.com/functions/docs/quickstart-nodejs).
- [Exemplo "hello world" com o Framework Serverless](https://www.serverless.com/framework/docs/providers/aws/examples/hello-world/node/).
- [Modelo de projeto com o framework Serverless](https://github.com/Rodolfobm/serverless-boilerplate).
- [Serverless (FaaS) vs. Contêineres](https://www.serverless.com/blog/serverless-faas-vs-containers/).