Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Backoff Exponencial no Erro HTTP 429

Aula 6 de 12 Atualizada a 30 de julho de 2026 Avancado
Nesta página
  1. Compreender o Erro 429
  2. Como Funciona o Backoff Exponencial
  3. Implementação Manual
  4. Utilizar a Biblioteca tenacity
  5. Combinar Backoff e Semáforo
  6. Adaptar o Backoff ao Tipo de Erro
  7. Pontos-chave

Compreender o Erro 429

Um erro HTTP 429 significa que excedeu os limites de taxa (rate limits) da API. O servidor xAI recusa temporariamente os seus pedidos para proteger a infraestrutura. Este erro é normal num contexto de processamento em lote: indica simplesmente que está a enviar pedidos demasiado depressa.

A reação adequada não é desistir, mas esperar antes de tentar novamente. O backoff exponencial é a estratégia padrão para lidar com esta situação.

Como Funciona o Backoff Exponencial

Em vez de tentar novamente imediatamente (o que desencadearia outro 429), aguarda um atraso crescente entre cada tentativa:

  • 1.ª falha: esperar 1 segundo
  • 2.ª falha: esperar 2 segundos
  • 3.ª falha: esperar 4 segundos
  • 4.ª falha: esperar 8 segundos
  • 5.ª falha: desistir

O atraso duplica a cada tentativa, daí o termo «exponencial». Isto dá tempo ao servidor para recuperar capacidade.

Implementação Manual

import asyncio
import random
from openai import RateLimitError

async def request_with_backoff(
    prompt: str,
    max_retries: int = 5,
    base_delay: float = 1.0
) -> str:
    for attempt in range(max_retries):
        try:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

        except RateLimitError:
            if attempt == max_retries - 1:
                raise  # última tentativa, propagar o erro

            delay = base_delay * (2 ** attempt)
            jitter = random.uniform(0, delay * 0.1)
            wait_time = delay + jitter

            print(f"Rate limit hit, attempt {attempt + 1}/{max_retries}. "
                  f"Waiting {wait_time:.1f}s")
            await asyncio.sleep(wait_time)

O jitter (variação aleatória) é importante. Se várias corrotinas receberem um 429 ao mesmo tempo, sem jitter tentariam todas novamente exatamente no mesmo instante, desencadeando outro 429. O jitter dessincroniza as tentativas.

Utilizar a Biblioteca tenacity

Para uso em produção, a biblioteca tenacity simplifica a implementação:

from tenacity import (
    retry,
    stop_after_attempt,
    wait_exponential,
    retry_if_exception_type
)
from openai import RateLimitError

@retry(
    stop=stop_after_attempt(5),
    wait=wait_exponential(multiplier=1, min=1, max=60),
    retry=retry_if_exception_type(RateLimitError)
)
async def robust_request(prompt: str) -> str:
    response = await client.chat.completions.create(
        model="grok-4.5",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

O decorador @retry interceta o RateLimitError, aguarda um atraso exponencial (entre 1 e 60 segundos) e tenta novamente até 5 vezes. O código da função mantém-se limpo e legível.

Combinar Backoff e Semáforo

Na prática, combina o backoff com um semáforo para um controlo total:

async def resilient_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)

    async def single_request(prompt: str) -> str:
        async with sem:
            return await request_with_backoff(prompt)

    tasks = [single_request(p) for p in prompts]
    return await asyncio.gather(*tasks, return_exceptions=True)

O semáforo impede a sobrecarga da API e o backoff trata os erros 429 residuais. Esta dupla proteção é a configuração recomendada para produção.

Adaptar o Backoff ao Tipo de Erro

Nem todos os erros justificam uma nova tentativa. Eis uma classificação:

from openai import RateLimitError, APITimeoutError, APIConnectionError, BadRequestError

async def smart_retry(prompt: str, max_retries: int = 5) -> str:
    for attempt in range(max_retries):
        try:
            return await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
        except RateLimitError:
            delay = 2 ** attempt
            await asyncio.sleep(delay)
        except (APITimeoutError, APIConnectionError):
            delay = 2 ** attempt
            await asyncio.sleep(delay)
        except BadRequestError:
            raise  # erro no prompt, retry inútil

Os erros 429 (limite de taxa), os timeouts e os erros de ligação merecem uma nova tentativa. No entanto, um BadRequestError (prompt inválido) não será resolvido ao tentar novamente.

Pontos-chave

  • Um erro 429 é normal e esperado durante o processamento em lote
  • O backoff exponencial duplica o atraso entre cada tentativa (1s, 2s, 4s, 8s…)
  • O jitter dessincroniza as novas tentativas para evitar colisões
  • A biblioteca tenacity simplifica a implementação em produção
  • Combine sempre semáforo e backoff para máxima resiliência
  • Não tente novamente em caso de erros de pedido inválido (BadRequestError)