DEV Community

LeoJulieta
LeoJulieta

Posted on

Código 483 – Evite que seu servidor “congele” recursos

483 – “I’m Not a Freezer”: O novo código de status que impede que seu servidor “congele” recursos

Introdução

Seu serviço está respondendo 200, mas, de repente, começa a recusar requisições sem motivo aparente?

A resposta pode estar no código 483 – “I’m Not a Freezer”, a proposta da IETF que deixa claro que o servidor está ativo, porém se recusa a receber mais carga para proteger recursos críticos.

Neste artigo você vai descobrir por que esse código foi criado, como usá‑lo na prática e o que fazer hoje para preparar sua API, tudo em linguagem direta e com exemplos reais.


1. O que é o código 483?

  • Definição: Código de status HTTP definido no draft HTTP/1.1 483 – I’m Not a Freezer (RFC‑draft‑httpbis‑483).
  • Semântica: “O servidor está disponível, mas recusa a requisição porque aceitá‑la poderia congelar (freeze) recursos críticos”.
  • Quando usar: Em situações de proteção proativa de CPU, memória, conexões de banco ou filas de mensagens, mesmo que o cliente não tenha excedido limites de taxa.

2. 483 × 429 × 503 – Quando escolher cada um

Código Situação típica O que o cliente deve entender
429 Too Many Requests Cliente ultrapassou limite de taxa (rate‑limit). “Aguarde e tente novamente depois do tempo indicado em Retry-After”.
503 Service Unavailable Servidor indisponível (manutenção, falha geral). “Volte mais tarde; o serviço está fora do ar”.
483 I’m Not a Freezer Servidor ativo, mas bloqueia carga para evitar degradação. “A requisição foi rejeitada por política interna; ajuste a carga ou espere que a situação melhore”.

3. Como implementar 483 na sua API

3.1 Exemplo em Node.js (Express)

app.use((req, res, next) => {
  const cpuLoad = os.loadavg()[0];           // carga média de 1 min
  const memFree = os.freemem() / os.totalmem();

  // Política simples: rejeitar se carga > 0.8 ou memória livre < 15%
  if (cpuLoad > 0.8 || memFree < 0.15) {
    res.status(483)
       .set('Retry-After', '30')   // sugerindo 30 s de pausa
       .json({
         error: "I’m Not a Freezer",
         message: "Serviço temporariamente protegido contra sobrecarga."
       });
  } else {
    next();
  }
});
Enter fullscreen mode Exit fullscreen mode

3.2 Exemplo em Nginx (module ngx_http_status_module)

http {
    # variável que indica uso de CPU (exemplo simplificado)
    set $cpu_load $upstream_cpu;

    if ($cpu_load > 0.8) {
        return 483 "I’m Not a Freezer\nRetry-After: 45";
    }

    # restante da configuração...
}
Enter fullscreen mode Exit fullscreen mode

3.3 Configuração no Istio (Envoy)

apiVersion: networking.istio.io/v1alpha3
kind: EnvoyFilter
metadata:
  name: reject-on-high-load
spec:
  configPatches:
  - applyTo: HTTP_FILTER
    match:
      context: SIDECAR_INBOUND
    patch:
      operation: INSERT_BEFORE
      value:
        name: envoy.filters.http.lua
        typed_config:
          "@type": type.googleapis.com/envoy.extensions.filters.http.lua.v3.Lua
          inlineCode: |
            function envoy_on_request(request_handle)
              local cpu = request_handle:streamInfo():dynamicMetadata():get("envoy.filters.http.ratelimit")["cpu_load"]
              if cpu and cpu > 0.8 then
                request_handle:respond(
                  {[":status"] = "483", ["retry-after"] = "20"},
                  "I’m Not a Freezer – alta carga"
                )
              end
            end
Enter fullscreen mode Exit fullscreen mode

4. Casos de uso reais

Cenário Por que 483? Benefício
Microserviços que compartilham pool de conexões ao banco Quando o pool atinge 90 % de ocupação, rejeitar novas chamadas evita deadlocks. Reduz latência de falhas e mantém a integridade transacional.
API de upload de arquivos em servidores com SSD limitado Ao detectar I/O próximo ao limite, recusar novos uploads impede perda de desempenho. Garante tempo de resposta estável para uploads já em andamento.
Gateway de API que protege serviços críticos de IA Modelos de inferência consomem GPU; quando a fila de GPU está cheia, 483 sinaliza a necessidade de back‑off. Evita sobrecarga da GPU e falhas de inferência.

5. Como preparar sua equipe hoje

  1. Mapeie recursos críticos – CPU, memória, conexões de banco, filas de mensagem, I/O de disco.
  2. Defina thresholds – Use métricas de observabilidade (Prometheus, Grafana) para estabelecer limites de “freeze”.
  3. Atualize o contrato da API – Documente o código 483 no OpenAPI/Swagger (responses: { "483": { description: "Serviço temporariamente protegido contra sobrecarga" } }).
  4. Implemente fallback – Clientes devem tratar 483 como “retry after” e, se possível, redirecionar a carga para outra região.
  5. Teste em staging – Simule picos de carga e verifique se o servidor devolve 483 antes de atingir 429 ou 503.

6. Perguntas frequentes (FAQ)

1. O código 483 já é padrão?

Ainda está em fase de draft (RFC‑draft‑httpbis‑483). Não há garantia de que será adotado integralmente, mas a maioria dos projetos open‑source já aceita códigos customizados.

2. Posso usar 483 em conjunto com Retry-After?

Sim. A especificação recomenda incluir Retry-After (em segundos ou data HTTP) para orientar o cliente sobre quando tentar novamente.

3. O 483 afeta caches HTTP?

Como é um código de erro, caches devem tratá‑lo como não‑cacheável, a menos que você adicione cabeçalhos explícitos (Cache-Control: no-store).

4. O que fazer se o cliente não reconhecer 483?

Trate-o como um erro genérico (5xx) e, se possível, envie um corpo JSON explicativo. A maioria dos SDKs modernos aceita códigos desconhecidos e repassa o número ao desenvolvedor.

5. Há risco de “over‑use” do 483?

Sim. Use‑o apenas quando a decisão for baseada em política de proteção e não em simples limitação de taxa; caso contrário, prefira 429.


7. Conclusão

O código 483 – “I’m Not a Freezer” chega para preencher a lacuna entre “muito tráfego” (429) e “serviço indisponível” (503). Ele permite que serviços críticos dizem ao cliente que a recusa é deliberada, preservando a estabilidade do sistema sem gerar alarmes de indisponibilidade total.

Adotar 483 hoje significa:

  • Comunicação mais clara com consumidores de API.
  • Proteção proativa de recursos limitados.
  • Menor risco de cascata de falhas em arquiteturas distribuídas.

Comece já a mapear seus pontos de estrangulamento, implemente a lógica de rejeição e atualize a documentação da sua API. Quando o padrão for oficializado, sua aplicação já estará pronta para usar o novo código com confiança.


Autor: [Seu Nome], Engenheiro de Plataforma – Especialista em APIs resilientes

Top comments (0)