Kurs Next.js · Moduł 5: Strategie renderowania
Performance Benchmarks w Next.js 16 - SSR vs SSG vs ISR
W tej lekcji7
W Metropolii Quantum roku 2150 wydajność systemów to kwestia przetrwania. Każda milisekunda opóźnienia może oznaczać utratę danych w kwantowej sieci lub awarię krytycznych systemów. Dlatego inżynierowie Metropolii muszą dokładnie rozumieć różnice wydajnościowe między strategiami renderowania w Next.js 16 i umieć wybrać optymalne rozwiązanie dla każdego przypadku.
Czym są benchmarki wydajności?
Benchmarki to pomiary wydajności aplikacji w kontrolowanych warunkach. Pozwalają porównać różne strategie renderowania pod kątem kluczowych metryk, takich jak:
- TTFB (Time to First Byte) - czas od wysłania żądania do otrzymania pierwszego bajtu odpowiedzi
- FCP (First Contentful Paint) - czas do wyrenderowania pierwszej treści na ekranie
- LCP (Largest Contentful Paint) - czas do wyrenderowania największego elementu w widoku
- TTI (Time to Interactive) - czas do pełnej interaktywności strony
- CLS (Cumulative Layout Shift) - stabilność wizualna strony podczas ładowania
Porównanie strategii renderowania
SSG (Static Site Generation) - najszybsza opcja
SSG generuje strony w czasie budowania aplikacji. Wynikowe pliki HTML są serwowane bezpośrednio z CDN, co zapewnia najniższe możliwe opóźnienia.
// app/blog/[slug]/page.tsx - SSG w Next.js 16
import { notFound } from 'next/navigation';
// Generowanie statycznych ścieżek w czasie budowania
export async function generateStaticParams() {
const posts = await fetch('https://api.example.com/posts').then(r => r.json());
return posts.map((post: { slug: string }) => ({ slug: post.slug }));
}
// Bez API czasu żądania strona jest prerenderowana przy budowaniu (SSG).
// Od Next.js 15 fetch nie jest domyślnie cachowany, więc cache włączamy jawnie
async function getPost(slug: string) {
const res = await fetch(`https://api.example.com/posts/${slug}`, { cache: 'force-cache' });
if (!res.ok) return null;
return res.json();
}
export default async function BlogPost({ params }: { params: Promise<{ slug: string }> }) {
const post = await getPost((await params).slug);
if (!post) notFound();
return (
<article>
<h1>{post.title}</h1>
<p>{post.content}</p>
</article>
);
}Typowe metryki SSG:
| Metryka | Wartość | Ocena |
|---|---|---|
| TTFB | 5-50ms | Doskonała |
| FCP | 100-300ms | Doskonała |
| LCP | 200-500ms | Doskonała |
| TTI | 300-800ms | Bardzo dobra |
| CLS | 0-0.05 | Doskonała |
SSR (Server-Side Rendering) - dynamiczna zawartość
SSR renderuje strony na serwerze przy każdym żądaniu. Jest wolniejsze niż SSG, ale zapewnia zawsze aktualne dane.
// app/dashboard/page.tsx - SSR w Next.js 16
import { cookies } from 'next/headers';
// Wymuszenie dynamicznego renderowania
export const dynamic = 'force-dynamic';
async function getDashboardData(token: string) {
const res = await fetch('https://api.example.com/dashboard', {
headers: { Authorization: `Bearer ${token}` },
cache: 'no-store', // Brak cachowania = SSR
});
return res.json();
}
export default async function Dashboard() {
const cookieStore = await cookies();
const token = cookieStore.get('auth-token')?.value || '';
const data = await getDashboardData(token);
return (
<div>
<h1>Panel użytkownika</h1>
<p>Saldo: {data.balance} QC</p>
<p>Ostatnia aktywność: {data.lastActivity}</p>
</div>
);
}Typowe metryki SSR:
| Metryka | Wartość | Ocena |
|---|---|---|
| TTFB | 100-500ms | Średnia |
| FCP | 300-800ms | Dobra |
| LCP | 500-1200ms | Średnia |
| TTI | 500-1500ms | Średnia |
| CLS | 0-0.1 | Dobra |
ISR (Incremental Static Regeneration) - kompromis
ISR łączy zalety SSG (szybkość) z SSR (aktualność danych). Strony są generowane statycznie, ale odświeżane w tle po upływie określonego czasu.
// app/products/page.tsx - ISR w Next.js 16
async function getProducts() {
const res = await fetch('https://api.example.com/products', {
next: { revalidate: 60 }, // Rewalidacja co 60 sekund
});
return res.json();
}
export default async function ProductsPage() {
const products = await getProducts();
return (
<div>
<h1>Produkty Quantum Store</h1>
<div className="grid">
{products.map((product: any) => (
<div key={product.id}>
<h2>{product.name}</h2>
<p>Cena: {product.price} QC</p>
</div>
))}
</div>
</div>
);
}Typowe metryki ISR:
| Metryka | Wartość (cache hit) | Wartość (rewalidacja) | Ocena |
|---|---|---|---|
| TTFB | 5-50ms | 100-400ms | Bardzo dobra |
| FCP | 100-300ms | 300-700ms | Bardzo dobra |
| LCP | 200-500ms | 500-1000ms | Dobra |
| TTI | 300-800ms | 500-1200ms | Dobra |
| CLS | 0-0.05 | 0-0.05 | Doskonała |
On-Demand Revalidation w Next.js 16
Rewalidacja na żądanie pozwala odświeżyć cache bez czekania na upłynięcie czasu rewalidacji. Next.js 16 zmienił jej API: revalidateTag przyjmuje teraz drugi argument, czyli profil cacheLife (zalecany 'max' oznacza, że użytkownik dostaje starą wersję, a świeża ładuje się w tle), a wersja z jednym argumentem jest przestarzała. W Server Actions do natychmiastowego odświeżenia służy nowa funkcja updateTag:
// app/api/revalidate/route.ts
import { revalidatePath, revalidateTag } from 'next/cache';
import { NextRequest, NextResponse } from 'next/server';
export async function POST(request: NextRequest) {
const { path, tag, secret } = await request.json();
// Weryfikacja tokenu bezpieczeństwa
if (secret !== process.env.REVALIDATION_SECRET) {
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
}
if (tag) {
// Rewalidacja po tagu - odświeża wszystkie fetche z danym tagiem
revalidateTag(tag, 'max');
return NextResponse.json({ revalidated: true, tag });
}
if (path) {
// Rewalidacja ścieżki - odświeża konkretną stronę
revalidatePath(path);
return NextResponse.json({ revalidated: true, path });
}
return NextResponse.json({ error: 'Missing path or tag' }, { status: 400 });
}
// Użycie tagów w fetch
async function getProduct(id: string) {
const res = await fetch(`https://api.example.com/products/${id}`, {
next: {
revalidate: 3600, // Cache na 1 godzinę
tags: [`product-${id}`, 'products'], // Tagi do rewalidacji
},
});
return res.json();
}Hybrid Rendering - mieszanie strategii
W Next.js 16 można łączyć różne strategie renderowania w ramach jednej strony dzięki Partial Prerendering (PPR). Wymaga ono włączenia cacheComponents: true: fragment z dyrektywą 'use cache' trafia wtedy do statycznej powłoki, a dynamiczny, owinięty w <Suspense>, jest dosyłany przy żądaniu. Bez tej opcji ten sam kod również streamuje dane, ale cała trasa renderuje się przy każdym żądaniu:
// app/store/page.tsx - Hybrid approach
import { Suspense } from 'react';
import { cacheLife } from 'next/cache';
// Statyczna część strony (SSG)
function StaticHeader() {
return (
<header>
<h1>Quantum Store</h1>
<nav>
<a href="/products">Produkty</a>
<a href="/categories">Kategorie</a>
</nav>
</header>
);
}
// Dynamiczna część strony (SSR)
async function DynamicCart() {
const res = await fetch('https://api.example.com/cart', { cache: 'no-store' });
const cart = await res.json();
return (
<div>
<h2>Twój koszyk ({cart.items.length} produktów)</h2>
<p>Suma: {cart.total} QC</p>
</div>
);
}
// Część cachowana (dawniej ISR) - trafia do statycznej powłoki
async function ProductList() {
'use cache';
cacheLife({ revalidate: 300 });
const res = await fetch('https://api.example.com/featured');
const products = await res.json();
return (
<div>
{products.map((p: any) => (
<div key={p.id}>{p.name} - {p.price} QC</div>
))}
</div>
);
}
export default function StorePage() {
return (
<div>
<StaticHeader />
<Suspense fallback={<p>Ładowanie koszyka...</p>}>
<DynamicCart />
</Suspense>
<Suspense fallback={<p>Ładowanie produktów...</p>}>
<ProductList />
</Suspense>
</div>
);
}Jak mierzyć wydajność w Next.js 16?
Web Vitals Reporting
// app/layout.tsx
import { SpeedInsights } from '@vercel/speed-insights/next';
import { Analytics } from '@vercel/analytics/react';
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
<html lang="pl">
<body>
{children}
<SpeedInsights />
<Analytics />
</body>
</html>
);
}Wbudowany profiler Next.js
# Budowanie z profilowaniem
NEXT_TELEMETRY_DEBUG=1 next build
# Analiza rozmiaru bundla
ANALYZE=true next buildKiedy użyć której strategii?
| Scenariusz | Strategia | Dlaczego? |
|---|---|---|
| Blog, dokumentacja | SSG | Treści się nie zmieniają często |
| E-commerce (lista produktów) | ISR (60-300s) | Produkty się zmieniają, ale nie co sekundę |
| Dashboard użytkownika | SSR | Dane muszą być zawsze aktualne |
| Strona główna z promocjami | ISR (300-3600s) | Promocje zmieniają się co kilka godzin |
| Panel administracyjny | SSR | Wymaga aktualnych danych i autoryzacji |
| Landing page | SSG | Maksymalna szybkość, statyczna treść |
| Feed społecznościowy | SSR + Streaming | Dynamiczne dane, progresywne ładowanie |
Podsumowanie
Wybór strategii renderowania w Next.js 16 powinien być podyktowany konkretnymi wymaganiami projektu:
- SSG - najszybsza opcja, idealna dla statycznych treści
- ISR - kompromis między szybkością a aktualnością danych
- SSR - pełna dynamiczność kosztem wydajności
- Hybrid (PPR) - przyszłość renderowania, łączący wszystkie strategie
W Metropolii Quantum 2150 inżynierowie opierają swoje decyzje na danych - mierzą, analizują i optymalizują. Benchmarki wydajności są kluczowym narzędziem w tym procesie.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Performance Benchmarks - SSR vs SSG vs ISR
interface BenchmarkResult {
strategy: string;
ttfb: number;
fcp: number;
lcp: number;
tti: number;
cls: number;
description: string;
useCase: string;
}
const benchmarks: BenchmarkResult[] = [
{
strategy: 'SSG (Static Site Generation)',
ttfb: 25,
fcp: 180,
lcp: 350,
tti: 500,
cls: 0.02,
description: 'Strony generowane w czasie budowania. Serwowane z CDN.',
useCase: 'Blog, dokumentacja, landing page',
},
{
strategy: 'ISR (Incremental Static Regeneration)',
ttfb: 30,
fcp: 200,
lcp: 400,
tti: 550,
cls: 0.03,
description: 'Statyczne strony odswiezane w tle po okreslonym czasie.',
useCase: 'E-commerce, katalogi produktow',
},
{
strategy: 'SSR (Server-Side Rendering)',
ttfb: 280,
fcp: 550,
lcp: 900,
tti: 1100,
cls: 0.08,
description: 'Strony renderowane na serwerze przy kazdym zadaniu.',
useCase: 'Dashboard, panel uzytkownika',
},
];
function MetricBar({ value, max, label, unit }: { value: number; max: number; label: string; unit: string }) {
const pct = (value / max) * 100;
const color = pct < 33 ? '#4caf50' : pct < 66 ? '#ff9800' : '#f44336';
return (
<div style={{ marginBottom: 8 }}>
<div style={{ display: 'flex', justifyContent: 'space-between', fontSize: 12, color: '#aaa', marginBottom: 2 }}>
<span>{label}</span>
<span style={{ color }}>{value}{unit}</span>
</div>
<div style={{ height: 8, background: '#1a2744', borderRadius: 4, overflow: 'hidden' }}>
<div style={{ width: pct + '%', height: '100%', background: color, borderRadius: 4, transition: 'width 0.6s ease' }} />
</div>
</div>
);
}
export default function BenchmarkDemo() {
const [selected, setSelected] = useState(0);
const b = benchmarks[selected];
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#fff', fontFamily: 'monospace' }}>
<h1 style={{ color: '#64ffda', fontSize: 20, marginBottom: 4 }}>Performance Benchmarks</h1>
<p style={{ color: '#888', fontSize: 13, marginBottom: 16 }}>SSR vs SSG vs ISR - porownanie wydajnosci</p>
<div style={{ display: 'flex', gap: 8, marginBottom: 20, flexWrap: 'wrap' }}>
{benchmarks.map((bm, i) => (
<button key={i} onClick={() => setSelected(i)} style={{
padding: '8px 14px', border: '1px solid ' + (i === selected ? '#64ffda' : '#334'),
background: i === selected ? '#1a3a4a' : '#151530', color: i === selected ? '#64ffda' : '#aaa',
borderRadius: 6, cursor: 'pointer', fontSize: 12,
}}>
{bm.strategy.split(' ')[0]}
</button>
))}
</div>
<div style={{ background: '#151530', borderRadius: 8, padding: 16, marginBottom: 16 }}>
<h2 style={{ color: '#64ffda', fontSize: 16, marginBottom: 4 }}>{b.strategy}</h2>
<p style={{ color: '#888', fontSize: 12, marginBottom: 12 }}>{b.description}</p>
<MetricBar value={b.ttfb} max={500} label="TTFB (Time to First Byte)" unit="ms" />
<MetricBar value={b.fcp} max={1200} label="FCP (First Contentful Paint)" unit="ms" />
<MetricBar value={b.lcp} max={1500} label="LCP (Largest Contentful Paint)" unit="ms" />
<MetricBar value={b.tti} max={1500} label="TTI (Time to Interactive)" unit="ms" />
<MetricBar value={b.cls} max={0.15} label="CLS (Cumulative Layout Shift)" unit="" />
</div>
<div style={{ background: '#151530', borderRadius: 8, padding: 12 }}>
<p style={{ color: '#64ffda', fontSize: 12, marginBottom: 4 }}>Najlepsze zastosowanie:</p>
<p style={{ color: '#ccc', fontSize: 13 }}>{b.useCase}</p>
</div>
</div>
);
}Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?