
CSR, SSR, streaming e isole: le forme di rendering dei framework frontend
Nuxt 4.5 ha portato lo streaming SSR, sperimentale. È l'occasione per mettere in fila tutte le forme di rendering, dal CSR alla resumability, e vedere quali framework offrono cosa.
Emanuele Nardi
Tra le novità di Nuxt 4.5, uscito a luglio, c'è un'opzione che sembra minore: experimental.ssrStreaming. Con lo streaming il server non aspetta di aver renderizzato tutta la pagina per mandarla: spedisce subito l'inizio e il resto man mano. Next.js lo fa dalla versione 13, Astro e SvelteKit da tempo, e per Nuxt era una richiesta aperta dal gennaio 2019.
Lo prendo come pretesto per mettere in fila tutte le forme di rendering che i framework frontend offrono: le sigle sono tante (CSR, SSR, SSG, ISR, PPR…) e ogni framework le combina a modo suo.
Tre domande
Qualsiasi modalità di rendering risponde a tre domande:
- Dove nasce l'HTML: durante la build, sul server o nel browser.
- Quando: una volta per tutte, a ogni richiesta, oppure una volta ogni tanto.
- Quanto JavaScript serve al browser perché la pagina risponda ai clic.
Le prime due decidono quanto aspetta l'utente prima di vedere qualcosa, e quanto sono freschi i dati che vede. La terza decide quanto aspetta prima di poterci fare qualcosa.
Le modalità di base
Lo schema mostra i quattro attori di una pagina web (build, server, CDN e browser) e cosa si passano in ciascuna modalità.
- Il browser riceve un HTML quasi vuoto e il bundle JavaScript
- Esegue il JavaScript, che chiede i dati alle API
- Solo allora disegna la pagina: fino a lì l’utente vede uno schermo vuoto o uno spinner
- CSR (Client-Side Rendering): il server manda un HTML vuoto e il browser costruisce tutto con JavaScript. Semplice da ospitare, ma l'utente aspetta il bundle e poi i dati, e un motore di ricerca che non esegue JavaScript vede una pagina vuota.
- SSR (Server-Side Rendering): a ogni richiesta il server esegue i componenti e restituisce l'HTML completo. Si vede subito il contenuto, con dati sempre freschi, al prezzo di un server che lavora a ogni visita.
- SSG (Static Site Generation): il rendering avviene una volta, durante la build. Le pagine sono file statici serviti da una CDN, velocissimi ed economici, ma i dati sono quelli della build. Questo sito è fatto così.
- ISR (Incremental Static Regeneration) e SWR (stale-while-revalidate): pagine statiche con una scadenza. Scaduta, la copia vecchia continua a essere servita mentre il server ne prepara una nuova in background.
I meta-framework moderni non obbligano a sceglierne una: con il rendering ibrido ogni rotta ha la sua. In Nuxt bastano le routeRules:
export default defineNuxtConfig({
routeRules: {
'/': { prerender: true }, // SSG
'/blog/**': { isr: 3600 }, // rigenerata al massimo una volta all'ora
'/prodotti/**': { swr: 60 }, // cache di Nitro, un minuto
'/admin/**': { ssr: false } // CSR
}
})
Idratazione: il prezzo dell'HTML dal server
SSR e SSG producono HTML visibile, che però resta inerte finché non arriva il JavaScript: i pulsanti non fanno niente. Il browser allora scarica il codice dei componenti, li riesegue e collega gli eventi ai nodi che esistono già. Si chiama idratazione.
Il suo difetto è ripetere un lavoro: il browser rifà quello che il server ha già fatto, solo per scoprire dove attaccare i listener. Nel frattempo la pagina sembra pronta ma non risponde. Buona parte delle novità degli ultimi anni, dalle isole alla resumability, serve a ridurre questo costo; ci torno più avanti.
Streaming: l'HTML a pezzi
Nell'SSR classico il server costruisce tutta la pagina in memoria e la manda in un colpo. Se un componente aspetta un'API lenta, aspetta tutta la pagina, e il browser riceve il primo byte solo alla fine. Il tempo al primo byte (TTFB, Time To First Byte) diventa quello della query più lenta.
Con lo streaming il server manda subito l'inizio del documento: il <head>, gli stili, i link al JavaScript. Il browser comincia a scaricare le risorse e a disegnare mentre il server continua a renderizzare. Lo schema confronta un caricamento con le diverse modalità; prova a passare da un'API veloce a una lenta.
Con un'API veloce le differenze sono di qualche centinaio di millisecondi. Con un'API lenta l'SSR classico lascia lo schermo bianco per più di un secondo, mentre lo streaming mostra subito la struttura della pagina e ha già scaricato il JavaScript quando arrivano i dati. La pagina statica non risente di niente: i dati li ha presi durante la build.
In ordine o fuori ordine
React fa streaming fuori ordine: un componente lento dentro un <Suspense> viene sostituito da un fallback, il resto della pagina prosegue, e quando i dati arrivano il server manda l'HTML vero con un piccolo script che lo mette al posto del fallback.
Vue, e con lui Nuxt, fa streaming in ordine: l'HTML esce nell'ordine del documento, e un componente che aspetta i dati ferma il flusso in quel punto. Quello che sta prima arriva subito, quello che sta dopo aspetta. Lo stesso vale per Astro.
import { Suspense } from 'react'
export default function Page() {
return (
<>
<Header />
{/* The fallback goes out first; the comments replace it when ready */}
<Suspense fallback={<p>Caricamento…</p>}>
<Comments />
</Suspense>
<Footer />
</>
)
}
<script setup lang="ts">
// The stream stops here until the data arrives; the header has already gone out
const { data: comments } = await useFetch('/api/comments')
</script>
<template>
<!-- AppHeader lives in the layout, so it is already on its way -->
<CommentList :comments />
<AppFooter />
</template>
Nel caso di Next.js il footer arriva subito, in quello di Nuxt arriva dopo i commenti. Per avere lo stesso effetto in Vue, la parte lenta va caricata nel client (useFetch con server: false), oppure spostata dopo tutto il resto della pagina.
Lo streaming in Nuxt 4.5
Si attiva con un'opzione:
export default defineNuxtConfig({
experimental: {
ssrStreaming: true
},
routeRules: {
// Pages that set status codes or cookies while rendering stay buffered
'/checkout/**': { streaming: false }
}
})
Ho guardato il renderer di Nuxt 4.6 per capire cosa succede a ogni richiesta.
- Con experimental.ssrStreaming attivo, ogni richiesta renderizzata dal server passa due controlli
- Se lo user agent è un bot (botRegex), la risposta resta bufferizzata, come senza streaming
- Lo stesso se la rotta ha una regola che vuole la pagina intera: redirect, cache o swr, isr, noScripts, ssr: false, streaming: false; e il prerender di nuxt generate non fa mai streaming
- Altrimenti Vue crea l’app e rende il primo pezzo; Nuxt invia la shell: head, stili, preload e script di ingresso
- Con il primo byte status e header sono partiti: cambiarli dopo (setResponseStatus, useCookie) non ha effetto, e in sviluppo Nuxt avvisa
- Il body arriva a pezzi; i tag head registrati più tardi arrivano come piccoli script
- Il payload chiude la risposta e il browser idrata la pagina
Alcune cose da sapere prima di attivarlo:
- Status e header partono con il primo byte. Dopo,
setResponseStatus(),useCookie()ouseResponseHeader()dentro un componente non arrivano più al browser: una pagina non trovata scoperta a metà rendering risponde comunque 200. In sviluppo Nuxt avvisa con un messaggio che nomina la rotta e le modifiche perse. - I bot ricevono la pagina intera. Di default, gli user agent che corrispondono a
botRegex(Googlebot, Bingbot e altri crawler) ottengono la risposta bufferizzata. Se imposti la tua espressione, sostituisce quella predefinita invece di aggiungersi. - Molte rotte tornano al buffer da sole: quelle con
redirect,cacheoswr,isr,noScriptsossr: false. Neanche le pagine prerenderizzate vanno in streaming, quindi un sito generato connuxt generate, come questo, non ne trae nulla. - L'idratazione parte alla fine. Il payload, cioè i dati che il client usa per non ripetere le richieste, chiude la risposta. Il JavaScript si scarica in anticipo, ma la pagina diventa interattiva solo a stream finito, tutta insieme.
- I tag
<head>tardivi (unuseHeadchiamato dopo unawait) non possono più finire nella shell: arrivano come piccoli script che aggiornano il documento. Un client senza JavaScript che non è nella lista dei bot non li vede.
Conviene sulle pagine renderizzate a ogni richiesta, con dati lenti nella parte bassa e senza logica che cambia lo status a metà. Per un sito statico o una pagina in cache non cambia niente.
Meno JavaScript: isole, Server Components, resumability
Lo streaming accelera l'arrivo dell'HTML; per accelerare il momento in cui la pagina risponde bisogna ridurre l'idratazione. Le strade sono tre, dalla più conservativa alla più radicale.
- Isole e idratazione differita. La pagina è HTML statico con qualche "isola" interattiva, ognuna idratata da sola, magari solo quando entra nello schermo. È il modello di Astro, con le direttive
client:visiblee simili. Nuxt dalla 3.16 ha l'idratazione differita: il codice del componente arriva comunque, ma gira solo quando serve. Angular ha l'idratazione incrementale con@defer (hydrate on viewport). - Server Components. Componenti che girano solo sul server e non mandano codice al browser: è il default dell'App Router di Next.js, ogni componente
.astrolo è, e in Nuxt ci sono i.server.vue, ancora sperimentali. - Resumability. Qwik non idrata affatto: serializza nell'HTML lo stato e i riferimenti ai gestori degli eventi, e scarica il codice di un gestore solo quando l'evento succede.
In Nuxt l'idratazione differita è una prop sul componente:
<template>
<ArticleBody :article />
<!-- The comments hydrate only when they scroll into view -->
<LazyCommentList
:comments
hydrate-on-visible
/>
</template>
C'è infine il Partial Prerendering (PPR) di Next.js, stabile dalla 16.0 con cacheComponents: una shell statica, pronta dalla build e servita dalla CDN, con i buchi dinamici riempiti in streaming nella stessa risposta. Unisce SSG e streaming, e tra i dieci framework della tabella è l'unico a offrirlo per intero; le server islands di Astro (server:defer) ci si avvicinano, ma riempiono i buchi con una richiesta separata.
Chi offre cosa
La tabella riassume dieci framework. Ogni cella si apre con un clic: c'è l'API da usare, la sfumatura e il link alla documentazione.
| Framework | CSR | SSR | SSG | ISR / SWR | Streaming | Ibrido per rotta | Isole | Server Components | PPR | Resumability |
|---|---|---|---|---|---|---|---|---|---|---|
| Nuxt4.6 | ||||||||||
| Next.js16.4 | ||||||||||
| SvelteKit3.1 | ||||||||||
| Astro7.4 | ||||||||||
| React Router8.5 | ||||||||||
| Angular22 | ||||||||||
| SolidStart2.2 | ||||||||||
| Qwik2.0 RC | ||||||||||
| TanStack Start1.x | ||||||||||
| Analog2.9 |
Nuxt 4.6 · StreamingSperimentale
L’HTML parte a pezzi mentre il server renderizza, invece che tutto alla fine.
experimental.ssrStreaming
Dalla 4.5. In ordine, mai per i bot, e l’idratazione parte a stream finito.
Documentazione di NuxtQualche osservazione:
- CSR, SSR, SSG e rendering ibrido ci sono quasi ovunque, con qualche limite: il CSR in Astro e Qwik, il rendering per rotta in SolidStart.
- ISR dipende molto dall'hosting. Nuxt, Next.js e Astro hanno un'API dedicata (in Nuxt
isrsi appoggia comunque alla CDN di Netlify o Vercel); gli altri passano da un adapter (SvelteKit con Vercel), da Nitro (SolidStart, Analog) o dagli headerCache-Controlletti dalla CDN. - Lo streaming c'è quasi ovunque, ma Angular manda ancora l'HTML in un pezzo solo: per lo streaming serve Analog, dove è sperimentale. Nuxt ci è arrivato solo quest'anno, e in via sperimentale.
- Next.js copre più caselle grazie ai Server Components e al PPR, al prezzo di un modello mentale più complesso: cache, confini di Suspense, componenti client e server.
- Astro e Qwik sono specialisti. Astro è nato per le isole, Qwik per la resumability, e secondo me lo fanno meglio di chi l'ha aggiunto dopo.
Come scegliere
Il mio criterio parte dalle tre domande dell'inizio:
- Se il contenuto cambia di rado, SSG, eventualmente con ISR per le pagine che si aggiornano.
- Se i dati dipendono dalla richiesta (l'utente, il carrello, una ricerca), SSR, con lo streaming quando una parte della pagina è lenta.
- Se dietro un login non serve indicizzazione, il CSR resta la soluzione più semplice da ospitare.
- Poi, a parte, quanto JavaScript serve: per un sito di contenuti con poca interattività, le isole o l'idratazione differita danno più di qualsiasi ottimizzazione del server.
Lo streaming di Nuxt aggiunge una possibilità al punto due, e il resto del quadro resta com'è. Per le pagine con un'API lenta in fondo è un guadagno netto e quasi gratuito; per tutto il resto la cosa più veloce resta un file HTML già pronto su una CDN.
Fonti
- Nuxt 4.5, la funzione sperimentale
ssrStreaminge la pull request #34411 - Nuxt: modalità di rendering, server components, idratazione differita
- Next.js: streaming con
loading.js, ISR,cacheComponents, export statico - Astro: isole, server islands, rendering on demand, cache
- SvelteKit: opzioni di pagina, streaming nel
load, adapter-vercel - React Router: prerendering, Suspense, React Server Components
- Angular: SSR, idratazione incrementale; Analog: streaming SSR
- SolidStart: configurazione; Qwik: resumability, Pending e streaming fuori ordine; TanStack Start: selective SSR, Server Components