Backoff Exponencial no Erro HTTP 429
Nesta página
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
tenacitysimplifica 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)