O que é degradação graciosa quando uma dependência falha?

Question

Accepted Answer

**Degradação graciosa** significa que quando uma dependência falha, o sistema **mantém o fluxo principal funcionando** ao servir uma experiência reduzida ou parcial em vez de retornar um erro. O objetivo é **falhar suavemente**, não falhar duramente: uma página degradada é melhor que um 500.

## Técnicas

- **Falha suave** — quando uma dependência está indisponível, sirva dados **em cache, parciais ou padrão** em vez de gerar um erro. Um resultado desatualizado mas presente geralmente é melhor que nada.
- **Desabilitar caminhos não-críticos com feature flags** — desative recomendações, analytics ou widgets sofisticados para que uma falha ali não possa quebrar a página principal.
- **Timeouts + fallbacks** — nunca aguarde indefinidamente por uma dependência lenta; estabeleça um tempo limite e mude para um valor ou caminho alternativo.
- **Isolar falhas (bulkheads)** — particione recursos (thread pools, connection pools) por dependência para que um serviço falhando não possa exaurir tudo e prejudicar o resto.
- **Proteger o fluxo principal** — identifique o caminho que deve funcionar (navegação, checkout) e garanta que recursos não-essenciais nunca consigam derrubá-lo.

## Exemplo: backend de busca está indisponível

```text
BAD  (fail hard):
  search() → backend timeout → throw → user sees HTTP 500 (whole page dead)

GOOD (fail soft):
  result = search()
         catch timeout → return cached_results OR empty + notice
  page renders:
    [ "Showing recent results — live search is temporarily unavailable." ]
    + cached listings, working nav, working checkout
  → user keeps browsing; core flow intact
```

Em vez de uma página morta, o usuário obtém resultados em cache e um pequeno aviso, enquanto a navegação e checkout continuam funcionando. A falha fica contida em um único recurso.

## Por que isso importa

Dependências *vão* falhar — APIs de terceiros, clusters de busca, serviços de recomendação. Sem degradação graciosa, qualquer falha em cascata resulta em uma interrupção completa. Projetar para falhar suavemente (dados em cache/parciais/padrão), desabilitar caminhos não-críticos, estabelecer timeouts com fallbacks e isolar falhas com bulkheads mantém o produto utilizável durante falhas parciais — o que faz a diferença entre um pequeno problema e um incidente crítico.