ISR, SSR ou statique : quel rendu choisir avec Next.js ?
Le bon mode de rendu se choisit page par page, et non pour tout un site. Voici une grille de décision simple, illustrée par deux cas réels : ce portfolio, entièrement statique, et l’e-commerce Cora, rendu à chaque requête, avec un point sur la revalidation et Cache Components dans Next.js 16.
« SSR ou ISR ? » est une question qu’on pose souvent pour un site entier. C’est une échelle trop grossière : dans une même application, la page d’accueil, une fiche produit et un panier n’ont pas les mêmes besoins. Cet article présente les questions que je me pose pour chaque page, deux cas réels qui aboutissent à des choix opposés et les évolutions du modèle de cache de Next.js 16.
Quels sont les modes de rendu de Next.js ?
- Statique : la page peut être pré-rendue au build lorsque toutes les données nécessaires sont connues à ce moment-là. Le résultat peut ensuite être servi directement aux visiteurs.
- ISR (Incremental Static Regeneration) : une page pré-rendue peut être régénérée périodiquement ou après une invalidation, sans reconstruire l’ensemble du site.
- Rendu dynamique : la réponse dépend de données disponibles au moment de la requête, par exemple une session, des cookies ou des en-têtes.
- Rendu côté client : une partie des données et de l’interface est récupérée ou mise à jour dans le navigateur. Il complète souvent le rendu serveur plutôt qu’il ne le remplace pour toute la page.
Avec l’App Router, le choix ne se résume pas à une option SSR ou ISR appliquée à toute l’application. Dans le modèle de cache classique, Next.js détermine ce qui peut être pré-rendu ou mis en cache en fonction des données utilisées par la route. Avec Cache Components activé, Next.js 16 propose en plus un modèle dans lequel une même route peut combiner une partie pré-rendue, des données mises en cache et du contenu dépendant de la requête.
Quelles questions se poser pour chaque page ?
La réponse dépend-elle de la requête ?
C’est souvent la première question à poser. Si une partie de la réponse dépend du visiteur, de sa session, d’un cookie ou d’un en-tête, cette partie ne peut pas être identique pour tout le monde. Dans le modèle classique de l’App Router, l’utilisation d’API liées à la requête peut rendre la route dynamique. Avec Cache Components, il est possible d’isoler cette partie dynamique dans une route qui conserve également une structure pré-rendue.
À quelle fréquence les données changent-elles ?
Un contenu qui ne change qu’au déploiement peut être pré-rendu au build. Un contenu qui change régulièrement sans dépendre du visiteur peut être mis en cache et revalidé périodiquement ou à la demande. La bonne fréquence dépend surtout de la fraîcheur réellement nécessaire : inutile de reconstruire une page à chaque requête si quelques minutes de décalage sont acceptables.
Combien de pages existe-t-il ?
Générer au build quelques dizaines de pages est généralement simple. Avec des dizaines de milliers de fiches produit, le temps de build peut devenir une contrainte. generateStaticParams permet de pré-générer les routes connues à l’avance ; selon la configuration, les autres peuvent être générées à la demande puis mises en cache.
La page doit-elle être indexable ?
Le rendu statique et le rendu serveur produisent tous deux du contenu HTML exploitable par les moteurs de recherche. Le rendu côté client n’empêche pas automatiquement l’indexation, mais il peut rendre la découverte et l’interprétation du contenu plus dépendantes de l’exécution JavaScript. Pour une page importante pour le référencement, fournir le contenu principal dès le rendu initial reste généralement préférable.
Pourquoi ce portfolio est-il entièrement statique ?
Le contenu de ce site (projets, articles, compétences) est écrit en TypeScript dans le dépôt. Il ne change donc qu’à l’occasion d’un nouveau déploiement, et rien ne justifie de reconstruire une page entre deux mises en ligne. Les pages sont donc pré-rendues au build, y compris les articles, les images de partage et le flux RSS :
// app/blog/[slug]/page.tsx (simplified): one page per article, generated at build time
export const dynamicParams = false; // an unknown slug is a 404
export function generateStaticParams() {
return blogPosts.map((post) => ({slug: post.slug}));
}
// app/blog/feed.xml/route.ts: the RSS feed is static too
export const dynamic = 'force-static';Avec dynamicParams à false, un slug qui ne fait pas partie des paramètres générés n’est pas rendu à la demande : il renvoie une 404. Cela correspond au modèle de contenu de ce portfolio, où la liste des articles est connue au moment du build.
Pourquoi l’e-commerce Cora était-il rendu à chaque requête ?
Sur l’e-commerce Cora, la réponse aux mêmes questions était différente. Le client choisissait son magasin parmi sept, et ce choix, stocké dans un cookie, influençait l’accès à l’e-shop, l’offre, les services et une partie des contenus, en français ou en néerlandais. Une même page devait donc tenir compte du magasin et de la langue sélectionnés.
Prégénérer toutes ces combinaisons puis les invalider au bon moment aurait ajouté une complexité importante. Nous avions donc retenu un rendu à la demande, capable de construire la réponse avec le contexte du magasin du client. La contrepartie était le temps nécessaire pour récupérer les données auprès de l’API ; c’est notamment ce qui nous a amenés à travailler sur la parallélisation des appels et la limitation des requêtes répétées. Le retour d’expérience sur Cora détaille ces arbitrages. Les contenus éditoriaux suivaient un autre chemin : un webhook Prismic appelait revalidateTag à chaque publication, pour invalider les données mises en cache sans attendre.
Et l’ISR, dans quels cas ?
Entre ces deux cas, la revalidation des données mises en cache convient bien aux pages dont le contenu évolue sans dépendre directement du visiteur, comme des articles de blog, un catalogue, une documentation ou du contenu éditorial. Dans le modèle de cache classique de Next.js 16, une revalidation temporelle peut être combinée à une invalidation à la demande :
// Simplified example
// Time-based: allow the cached result to be revalidated after one hour
export const revalidate = 3600;
// On-demand: a CMS webhook marks tagged data as stale
// app/api/revalidate/route.ts
import {revalidateTag} from 'next/cache';
export async function POST() {
revalidateTag('products', 'max');
return Response.json({revalidated: true});
}Le délai suffit lorsque quelques minutes de décalage sont acceptables. Une invalidation à la demande est plus adaptée lorsqu’un CMS sait précisément qu’un contenu vient d’être modifié. Avec revalidateTag(..., 'max'), Next.js marque les données concernées comme obsolètes et peut servir la version précédente pendant qu’une nouvelle version est récupérée en arrière-plan. Si une Server Action doit au contraire appliquer immédiatement une modification visible par l’utilisateur, updateTag répond à ce besoin de lecture immédiate de ses propres changements.
Deux comportements surprennent la première fois. Une fois le délai écoulé, la page n’est pas reconstruite tout de suite. La requête suivante reçoit encore l’ancienne version, la nouvelle se génère en arrière-plan, et ce n’est qu’à la requête d’après qu’elle est servie. Le second tient au « I » d’ISR, pour incrémental. Sur une route dynamique, une page absente de generateStaticParams, comme un article publié après le build, est générée à sa première visite puis mise en cache, sauf si dynamicParams vaut false, comme sur ce portfolio, où elle renvoie une 404. Ce fonctionnement est celui du modèle de cache classique. Avec Cache Components, l’ISR passe par "use cache" et cacheLife, présentés dans la section suivante.
Qu’est-ce qui a changé dans Next.js 16 ?
- revalidateTag accepte désormais un profil de cache en second argument. "max" est recommandé pour le cas courant de stale-while-revalidate ; la forme à un seul argument est dépréciée. Pour une Server Action qui doit rendre immédiatement visible une modification à l’utilisateur, updateTag fournit un comportement différent, avec expiration immédiate des données concernées.
- Cache Components est un modèle de rendu et de cache optionnel, activé avec cacheComponents. La directive "use cache", associée à cacheLife et cacheTag, permet de contrôler explicitement les parties mises en cache. Les données dépendant de la requête peuvent rester dynamiques et être rendues autour d’une structure pré-rendue, notamment avec Suspense et le streaming.
- Le fichier middleware.ts a été renommé en proxy.ts dans Next.js 16. Le changement concerne le nom de la convention et non le principe général d’interception des requêtes.
Les deux modèles de cache peuvent donc coexister selon le projet. Ce portfolio reste volontairement simple et statique ; Cache Components devient intéressant lorsqu’une même route doit combiner du contenu pré-rendu, des données mises en cache et une partie dépendante de la requête. Les détails de comportement dépendent toutefois de la configuration choisie : mieux vaut vérifier la documentation de la version réellement utilisée plutôt que d’appliquer mécaniquement un exemple prévu pour une version précédente.
Quels pièges éviter ?
- Lire les cookies ou les en-têtes dans une route en supposant que cela reste compatible avec un rendu entièrement statique. Dans le modèle de cache classique, ces API peuvent rendre la route dynamique ; avec Cache Components, la partie dépendante de la requête peut au contraire être isolée du contenu pré-rendu.
- Mettre en cache une donnée personnelle dans un cache partagé : une session, un panier ou toute autre donnée propre à un utilisateur ne doit pas être exposée à un autre visiteur. Avec "use cache", les données de requête doivent être traitées avec le modèle de cache approprié.
- Compter sur l’ISR avec un export statique : les mécanismes de revalidation côté serveur ne peuvent pas fonctionner de la même manière sans serveur, puisque l’application exportée ne dispose pas du runtime nécessaire pour régénérer les pages.
- Déployer plusieurs instances sans réfléchir à la coordination du cache : par défaut, une invalidation effectuée sur une instance peut ne pas être immédiatement connue des autres. Un cache partagé ou un mécanisme de coordination adapté devient alors nécessaire.
- Croire qu’une invalidation régénère la page aussitôt : revalidatePath et revalidateTag marquent le cache comme obsolète, mais la nouvelle version n’est produite qu’à la requête suivante.
- Confondre revalidation et purge d’un éventuel CDN : revalidateTag ou revalidatePath agissent sur le cache de Next.js ; un CDN placé devant l’application peut nécessiter sa propre invalidation pour cesser immédiatement de servir une ancienne réponse.
Quelle grille de décision retenir ?
- Contenu connu au build et identique pour tous : pré-rendu statique.
- Contenu identique pour tous mais régulièrement mis à jour : cache avec revalidation temporelle ou à la demande.
- Contenu dépendant de la requête ou de l’utilisateur : rendu dynamique, ou séparation entre partie pré-rendue et partie dynamique avec Cache Components.
- Partie très interactive, comme un panier en cours d’édition ou certains filtres : composant client au sein d’une page qui peut elle-même rester rendue côté serveur.
Ce raisonnement évite de choisir un mode de rendu par habitude. Le bon choix dépend du contenu nécessaire au moment où la réponse est produite, de sa fréquence de mise à jour et du coût acceptable côté serveur.