Node.js - Limitação de taxa de API
Tags: javascript, programming, beginners, limit
Published: 2022-02-26 04:17:58

![API](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/u0h179ujgfcx9g5e57lc.png)
 
Como desenvolvedores, é muito importante garantir que as APIs que executamos sejam o mais eficiente possível. Caso contrário, os usuários sofrerão com o desempenho lento.

### **Por que você precisa de limitação de API?**

O desempenho também não é o único motivo para limitar as solicitações de API. **A limitação de API** , que também é conhecida como [limitação de taxa](https://nordicapis.com/stemming-the-flood-how-to-rate-limit-an-api/) , é um componente essencial da **segurança** da Internet , pois os ataques DoS podem sobrecarregar um servidor com solicitações de API ilimitadas.

A limitação de taxa também ajuda a tornar sua API **escalável** . Se sua API explodir em popularidade, pode haver picos inesperados no tráfego, causando um grande atraso.

### **Como funcionam os limites de taxa?**

Os limites de taxa atuam como gatekeepers para controlar a quantidade de tráfego de entrada ou saída de ou para uma rede. Um limite de taxa de API pode impor, digamos, 100 solicitações por minuto. Quando as solicitações excedem esse número, ele gera uma mensagem de erro para alertar o solicitante de que excedeu o número de solicitações alocadas em um período de tempo específico.

### **Tipos de Limites de Taxa**

**Limitação de taxa de usuário**

O tipo mais comum de limitação de taxa, limitação de taxa de usuário, monitora a chave de API de um usuário, o cookie de sessão e o endereço IP para observar o número de solicitações feitas. Se o número de solicitações exceder o limite, o usuário deve aguardar até que o período de tempo seja redefinido, o que geralmente é indicado por uma quantidade de tempo de espera enviada por meio de uma mensagem anexada ao cabeçalho “Retry-After”.

**Limitação de taxa baseada no tempo**

Isso geralmente se baseia na região e na hora do dia em que o usuário está tentando acessar uma rede. Ele existe para garantir que os protocolos estritos de limitação de taxa se apliquem apenas a determinados períodos de tempo em que o tráfego será mais alto. Muitas vezes, isso envolve o aumento do número de solicitações permitidas entre as 12h e as 8h, pois o tráfego tende a ser o mais baixo geral nesse período.

**Limitação da taxa do servidor**

Dependendo do tamanho da API, você pode ter vários servidores lidando com diferentes tipos de solicitações. A limitação de taxa de servidor é o processo de impor limites diferentes em uma base de servidor por servidor.

### **Como implementar a limitação de taxa no Node.js?**

A **[express-rate-limit](https://www.npmjs.com/package/express-rate-limit)** é uma biblioteca simples e direta que resolve esse problema para nós. Não é o mais completo, mas é uma forma leve e rápida de atingir esse objetivo. Para opções mais refinadas, o próprio **[express-rate-limit](https://www.npmjs.com/package/express-rate-limit)** já recomenda outras bibliotecas como **[rate-limiter-flexible](https://www.npmjs.com/package/rate-limiter-flexible) , [express-brute](https://www.npmjs.com/package/express-brute) e [express-limiter](https://www.npmjs.com/package/express-limiter) .**

### **Instalar e configurar**

- Em primeiro lugar, você precisa de um projeto **node.js.** `npm init -y`
    
    Portanto, crie um diretório e execute o comando para criar um arquivo **package.json**
    
    padrão .
    
- Em seguida, instale os pacotes necessários para o aplicativo: o [express](https://www.npmjs.com/package/express)[express-rate-limit](https://www.npmjs.com/package/express-rate-limit) `npm install express express-rate-limit`
    
    e o
    
- Configuração expressa. Para facilitar a execução, atualize seu arquivo **package.json**`npm start`
    
    e adicione um script de início. Ele nos permitirá executar o projeto com o
    
    comando
    
    ```jsx
    ... 
      "scripts": { 
        "start": "node index.js" 
      }, 
    ...
    ```
    

- Em seguida, crie um arquivo `index.js` no diretório raiz para ser seu ponto de entrada. Assim, você pode colocar o código de início expresso
mais genérico .

```jsx
// importação express
const express = require('express') 
// inicialização express 
const app = express() 

const PORT = 3000 

// rota GET genérica que usaremos para os testes 
app.get('/', function (req , res) { 
  return res.send('Hello World') 
}) 

// inicialização do servidor 
app.listen(PORT, () => { 
    console.log(`servidor iniciado na porta ${PORT}`) 
})
```

- Então, quando executamos o `npm start`(ou `node index.js`se você pulou a etapa `package.json`), ele deve exibir essa mensagem indicando que o aplicativo está funcionando:

![Server](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4oo9qynriejsp1gpoksu.png)
 

- E ao acessar a `localhost:3000`rota "/" exibirá o `Hello World`que configuramos.

![Hello](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2uxsrszr95w6eqftnyfu.png)
 

### **Adicionando o limite de taxa**

Como já adicionamos o [express-rate-limit](https://www.npmjs.com/package/express-rate-limit) na primeira etapa, precisamos começar a usá-lo.

O **express-rate-limit** funciona como um middleware, o que significa que podemos usá-lo em uma única rota, em todo o aplicativo ou em um grupo de sub-rotas.

Para isso, precisamos apenas entender como o **express** trata os middlewares, mas sendo bem direto ao ponto, usaremos a `use`função do express para adicionar um middleware ou manipulador de requisições na raiz da nossa API para envolvê-lo inteiramente.

Agora vamos usar:

- Primeiro, precisamos importar o limite de taxa expressa em nosso código logo abaixo da importação expressa

```jsx
// /index.js 
const express = require('express') 
const rateLimit = require('express-rate-limit') 
// ...
```

- Então podemos configurar a caixa de tempo em milissegundos e o número máximo de solicitações por endereço IP (máximo)

```jsx
// /index.js 
const express = require('express') 
const rateLimit = require('express-rate-limit') 
const app = express()
const PORTA = 3000
// Cria a regra de limite de taxa 
const apiRequestLimiter = rateLimit({ 
    windowMs: 1 * 60 * 1000, // 1 minuto 
    máximo: 2 // limita cada IP a 2 solicitações por windowMs 
})
// Use a regra de limite como um middleware de aplicativo 
app.use(apiRequestLimiter)
app.get('/', function (req, res) { 
  return res.send('Hello World') 
})
app.listen(PORT, () => { 
    console.log(`servidor iniciado na porta ${PORT}`) 
})
```

Então essa será a resposta padrão, que tínhamos antes:

![Hello World](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ivfl0p7t4uq0259ohd9s.png)
 
E quando o limite for excedido, ele exibirá uma mensagem padrão `Too many requests, please try again later.`:

![Too Many](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wlcd7algltrpm44ghnso.png)
 
Para alterar esta mensagem temos duas opções:

1. Adicione uma propriedade “message” dentro do objeto passado como parâmetro para a `rateLimit` função

```jsx
const apiRequestLimiter = rateLimit({ 
    windowMs: 1 * 60 * 1000, // 1 minuto 
    máx.: 2, // limita cada IP a 2 solicitações por mensagem windowMs 
    : "Seu limite excedido" 
})
```

2. Adicione uma função de manipulador para processar o caso de falha:

```jsx
const apiRequestLimiter = rateLimit({ 
    windowMs: 1 * 60 * 1000, // 1 minuto 
    máximo: 2, // limita cada IP a 2 solicitações por manipulador de windowMs 
    : function (req, res, /*next*/) { 
        return res. status(429).json({ 
          error: 'Você enviou muitas solicitações. Aguarde um pouco e tente novamente' 
        }) 
    } 
})
```

Pronto agora você deixou sua API um pouco mais segura contra várias requisições em massa.

Fontes onde pesquisei esse conteúdo:

- https://nordicapis.com/stemming-the-flood-how-to-rate-limit-an-api/