Kurs Next.js · Moduł 5: Strategie renderowania

Performance Benchmarks w Next.js 16 - SSR vs SSG vs ISR

7 min czytania ·
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:

MetrykaWartośćOcena
TTFB5-50msDoskonała
FCP100-300msDoskonała
LCP200-500msDoskonała
TTI300-800msBardzo dobra
CLS0-0.05Doskonał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:

MetrykaWartośćOcena
TTFB100-500msŚrednia
FCP300-800msDobra
LCP500-1200msŚrednia
TTI500-1500msŚrednia
CLS0-0.1Dobra

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:

MetrykaWartość (cache hit)Wartość (rewalidacja)Ocena
TTFB5-50ms100-400msBardzo dobra
FCP100-300ms300-700msBardzo dobra
LCP200-500ms500-1000msDobra
TTI300-800ms500-1200msDobra
CLS0-0.050-0.05Doskonał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 build

Kiedy użyć której strategii?

ScenariuszStrategiaDlaczego?
Blog, dokumentacjaSSGTreści się nie zmieniają często
E-commerce (lista produktów)ISR (60-300s)Produkty się zmieniają, ale nie co sekundę
Dashboard użytkownikaSSRDane muszą być zawsze aktualne
Strona główna z promocjamiISR (300-3600s)Promocje zmieniają się co kilka godzin
Panel administracyjnySSRWymaga aktualnych danych i autoryzacji
Landing pageSSGMaksymalna szybkość, statyczna treść
Feed społecznościowySSR + StreamingDynamiczne dane, progresywne ładowanie

Podsumowanie

Wybór strategii renderowania w Next.js 16 powinien być podyktowany konkretnymi wymaganiami projektu:

  1. SSG - najszybsza opcja, idealna dla statycznych treści
  2. ISR - kompromis między szybkością a aktualnością danych
  3. SSR - pełna dynamiczność kosztem wydajności
  4. 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?

  1. Projekt do wysłaniaLink
  2. WideoVideo: Podsumowanie modułu

Przydatne artykuły