Como controlar o volume máximo de requisições à APIs

Visão geral

Em todas as APIs do Zeev existe um volume máximo de requisições por segundo, por minuto, por hora e por dia. Caso o limite extrapole, a chamada à API retornará um com código 429 - Too Many Requests.

Esse limite é fundamental para manter e assegurar a performance geral do sistema. Altos volumes de requisições à API podem comprometer a experiência geral dos usuários finais no uso do dia-a-dia.

Quais os limites

Para ambientes hospedados na nuvem SaaS da Zeev, os limites são definidos conforme o seu volume de licenciamento. Você pode encontrar essa informação em nossos Termos Técnicos de Uso.

Técnicas para respeitar o limite

Implemente Sleep

Em geral, um algoritmo em linguagem de programação executa em milissegundos, e não em segundos. Isso significa que se você tiver 2 chamadas de API em sequencia, provavelmente receberá erro 429 pois ela será executada abaixo do tempo mínimo de 1 segundo entre chamadas.

Todas as linguagens de programação possuem funções de sleep, que consistem em parar o código por um determinado momento. Adicionar uma função de sleep de 1 segundo após cada chamada de API assegura que a próxima chamada não executará com erro.

Veja abaixo 3 exemplos de implementação teórica de sleep, com javascript, C# e Python

Node.js

async function fetchData() {
  const url = 'https://api.exemplo.com/dados';
  const headers = { 
    'Content-Type': 'application/json',
    'Authorization': 'Bearer token-de-autenticação' 
  };

  try {
    const response1 = await fetch(url, { headers: headers });
    const data1 = await response1.json();
    console.log('Response 1:', data1);

    //Espera por 200 millisegundos
    await new Promise(resolve => setTimeout(resolve, 200));

    const response2 = await fetch(url, { headers: headers });
    const data2 = await response2.json();
    console.log('Response 2:', data2);
  } catch (error) {
    console.error('Error:', error);
  }
}

fetchData();

C#

static async Task Main()
{
    using (HttpClient client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", "Bearer token-de-autenticação");

        try
        {
            HttpResponseMessage response1 = await client.GetAsync("https://api.exemplo.com/dados");
            response1.EnsureSuccessStatusCode();
            string responseBody1 = await response1.Content.ReadAsStringAsync();
            Console.WriteLine("Response 1: " + responseBody1);

            Thread.Sleep(200); // Pause for 200 milliseconds

            HttpResponseMessage response2 = await client.GetAsync("https://api.exemplo.com/dados");
            response2.EnsureSuccessStatusCode();
            string responseBody2 = await response2.Content.ReadAsStringAsync();
            Console.WriteLine("Response 2: " + responseBody2);
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine("\nException Caught!");
            Console.WriteLine("Message :{0} ", e.Message);
        }
    }
}

Python

import requests
import time

async def fetchData():
    url = "https://api.exemplo.com/dados"
    headers = {"Authorization": "Bearer token-de-autenticação"}

    response1 = requests.get(url, headers=headers)
    print('Response 1:', response1.status_code, response1.text)

    time.sleep(0.2)  # Sleep for 200 milliseconds

    response2 = requests.get(url, headers=headers)
    print('Response 2:', response2.status_code, response2.text)

fetchData()

Implemente Backoff Exponencial

Se você atingir o limite de solicitações por segundo, implemente uma estratégia de backoff exponencial. Isso significa que, ao receber um código de resposta 429, você deve esperar um período de tempo crescente antes de fazer outra tentativa.

Comece com uma pequena pausa e aumente progressivamente o tempo de espera em cada tentativa subsequente.

Por exemplo, no primeiro erro 429, aguarde 1 segundo. No segundo erro 429, aguarde 2 segundos. E assim sucessicamente.

Implemente biblioteca ou módulo de Rate Limiting

Muitas linguagens de programação têm bibliotecas ou módulos que facilitam o gerenciamento de rate limits. Essas ferramentas podem ajudar a automatizar a lógica de backoff exponencial e monitorar o uso da cota. Procure por bibliotecas especializadas com base na linguagem de programação que você está utilizando.

Implemente cache local

Considere implementar um mecanismo de cache local para armazenar as respostas das solicitações anteriores feitas ao Zeev. Isso pode reduzir a necessidade de fazer repetidas solicitações ao mesmo serviço.

Estabeleça limites próprios

Mesmo que o Zeev imponha limites, você pode implementar seus próprios limites de taxa para evitar atingir os limites do serviço. Isso pode ajudar a controlar seu próprio uso da API e evitar atingir os limites impostos pelo serviço.

Monitore e registre solicitações

Mantenha registros detalhados de todas as solicitações feitas ao serviço do Zeev, incluindo horários, códigos de resposta e quaisquer cabeçalhos relevantes. Isso pode ajudar na depuração e no ajuste fino de sua estratégia de rate limiting.

Como aumentar esse limite

Após análise e aprovação técnica, é possível avaliar o aumento dos limites através da contratação de pacotes adicionais. Contate nossas equipes comerciais para mais detalhes.