# Construire des Systèmes Résilients avec Next.js
> Bonnes pratiques pour garantir haute disponibilité et performance dans les applications web modernes.
>
> 2024-08-22 — y7.hk
## L'Architecture d'Abord
Next.js sert souvent d'épine dorsale aux applications web modernes. Garantir la résilience exige un mélange de bonnes décisions architecturales et d'outillage adapté.
En exploitant les Server Components et des error boundaries bien implémentés, on peut construire des applications web extrêmement résilientes qui dégradent élégamment au lieu de s'effondrer complètement.
### Static Generation vs SSR
Dès que possible, privilégier l'Incremental Static Regeneration (ISR). Cela garantit que même si vos APIs backend sont temporairement indisponibles, les utilisateurs verront la dernière version buildée avec succès.
Mais le compromis est réel : l'ISR donne la résilience au prix de la fraîcheur. Le SSR donne la fraîcheur au prix d'une dépendance dure au backend.
```tsx
// app/blog/[slug]/page.tsx
export const revalidate = 300; // 5 minutes
export default async function Post({ params }) {
const post = await fetchPost(params.slug); // caché + revalidé
return ;
}
```
Quand mon API d'origine est tombée pendant 40 minutes lors d'un incident Cloudflare l'an dernier, toutes les pages ISR de y7.hk ont continué à servir du HTML périmé-mais-valide. Les pages SSR du même site renvoyaient des 500. Cette expérience m'a coûté 4 % de trafic mensuel — et a changé définitivement ma façon de penser la stratégie de rendu.
**Règle empirique :** ISR pour tout ce qui tolère 5–60 minutes d'ancienneté (articles de blog, pages produit, marketing). SSR uniquement quand l'ancienneté casse le produit (dashboards live, état d'auth, données temps réel).
### Les Error Boundaries sont des Cloisons
Sans boundary, un seul widget qui échoue fait s'effondrer toute la page. Avec boundary, chaque section échoue indépendamment.
```tsx
// app/components/Section.tsx
'use client';
import { Component, ReactNode } from 'react';
export class Section extends Component<
{ children: ReactNode; fallback?: ReactNode },
{ hasError: boolean }
> {
state = { hasError: false };
static getDerivedStateFromError() {
return { hasError: true };
}
render() {
if (this.state.hasError) {
return this.props.fallback ??
Section indisponible
;
}
return this.props.children;
}
}
```
Enveloppez chaque unité indépendante — widgets de sidebar, sections de commentaires, dashboards analytics — dans son propre boundary. L'utilisateur voit une boîte grise là où était le widget, pas un écran blanc.
Je l'ai appris à la dure sur un dashboard Web3 où un seul timeout RPC a crashé toute la vue portfolio. Un boundary autour du ticker de prix aurait sauvé la session.
### Les Retries Ont Besoin de Backoff
Les retries aveugles amplifient les pannes. Le backoff exponentiel avec jitter répartit la charge et donne à l'upstream le temps de récupérer.
```ts
async function fetchWithRetry(
fn: () => Promise,
attempts = 3,
baseDelay = 300
): Promise {
for (let i = 0; i < attempts; i++) {
try {
return await fn();
} catch (err) {
if (i === attempts - 1) throw err;
const jitter = Math.random() * baseDelay;
await new Promise(r => setTimeout(r, baseDelay * 2 ** i + jitter));
}
}
throw new Error('unreachable');
}
```
Deux règles que je suis :
1. **Jamais de retry sur 4xx.** Un 404 ne devient pas un 200 en retry.
2. **Plafonner l'attente totale.** Si l'utilisateur regarde un spinner depuis 8+ secondes, affichez le fallback UI et laissez-le continuer.
### Les Circuit Breakers Coupent les Cascades
Les retries résolvent les erreurs transitoires. Les circuit breakers résolvent les erreurs persistantes. Si votre backend échoue depuis 30 secondes, arrêtez de le marteler — ouvrez le circuit et servez immédiatement des réponses dégradées.
```ts
class Breaker {
private failures = 0;
private openUntil = 0;
constructor(private threshold = 5, private cooldown = 30_000) {}
async call(fn: () => Promise): Promise {
if (Date.now() < this.openUntil) throw new Error('Circuit open');
try {
const result = await fn();
this.failures = 0;
return result;
} catch (e) {
if (++this.failures >= this.threshold) {
this.openUntil = Date.now() + this.cooldown;
}
throw e;
}
}
}
```
Sans breaker, un upstream lent se transforme en flotte de processus Node gelés. Avec un breaker, vous obtenez des échecs rapides et un système qui récupère dès le retour de l'upstream.
### Edge Caching avec stale-while-revalidate
Le header `Cache-Control` est la couche de résilience la moins chère dont vous disposez. `stale-while-revalidate` permet à l'edge de servir la dernière copie cachée pendant qu'il récupère une version fraîche en arrière-plan.
```
Cache-Control: public, s-maxage=60, stale-while-revalidate=600
```
C'est la différence entre « l'API est tombée donc le site est tombé » et « l'API est tombée donc certains utilisateurs voient des données vieilles de 10 minutes ».
### Le Fallback UI comme Feature
Les fallbacks ne sont pas ce qu'on montre quand quelque chose casse — ils font partie du design. Chaque section asynchrone a trois états :
- **Loading :** skeleton qui correspond au layout final (pas de layout shift).
- **Success :** le contenu réel.
- **Error :** une version dégradée qui permet toujours à l'utilisateur de faire son travail.
Si votre widget de prix échoue, n'affichez pas une erreur rouge — affichez les derniers prix cachés avec un petit badge « mis à jour il y a 12 min ». Si le système de commentaires échoue, affichez le thread en lecture seule et masquez le champ de saisie.
### Tolérance Offline
Les Service Workers ne sont pas que pour les PWA. Un SW minimal qui cache l'app shell et les 5 dernières pages visitées offre une vraie tolérance offline sur le wifi bancal des hôtels et à 10 000 mètres d'altitude — ce qui, si vous êtes moi, représente une part non négligeable de votre navigation.
```ts
// sw.ts — cache-first pour le statique, network-first pour les pages
self.addEventListener('fetch', (e) => {
const url = new URL(e.request.url);
if (url.pathname.startsWith('/_next/static/')) {
e.respondWith(caches.match(e.request).then(r => r ?? fetch(e.request)));
}
});
```
### Pannes Réelles que J'ai Vécues
- **Panne Cloudflare edge KV :** chaque page dépendant de KV a renvoyé 500. Les pages ISR ont survécu.
- **Le CMS upstream m'a rate-limité pendant un pic de trafic.** Pas de breaker ; Next.js a martelé le CMS jusqu'à un ban IP dur. Maintenant chaque appel externe passe par un breaker avec cooldown de 30 s.
- **Un seul `` a crashé tout le dashboard** quand le WebSocket a lâché. Après l'ajout d'un boundary, le reste de l'UI est resté vivant pendant que le ticker se reconnectait silencieusement.
## Checklist Résilience
- [ ] ISR/SSG pour le contenu tolérant 5+ min d'ancienneté
- [ ] `stale-while-revalidate` sur chaque route cachable
- [ ] Error boundary autour de chaque widget indépendant
- [ ] Backoff exponentiel + jitter sur les retries ; jamais de retry 4xx
- [ ] Circuit breaker sur chaque appel de service externe
- [ ] Skeleton + fallback + état d'erreur pour chaque UI async
- [ ] Service worker cachant l'app shell
- [ ] Kill-switch documenté pour les features non critiques (analytics, recommandations)
## L'Essentiel
La résilience n'est pas une feature qu'on visse à la fin. C'est l'architecture elle-même. Chaque couche — rendu, cache, fetching, UI — reçoit son mode de défaillance conçu dès le départ. Construisez-les tôt, et les incidents qui auraient été des pannes deviennent des dégradations silencieuses que personne ne remarque.