Kurs Next.js · Moduł 5: Strategie renderowania

Edge Runtime i optymalizacja wydajności

19 min czytania ·
W tej lekcji8

W świecie nowoczesnych aplikacji webowych wydajność jest kluczowym czynnikiem wpływającym na doświadczenie użytkownika i sukces biznesowy. Next.js oferuje zaawansowane narzędzia do optymalizacji wydajności, wśród których Edge Runtime wysuwa się na pierwszy plan jako potężne rozwiązanie. W tym module omówimy Edge Runtime oraz inne strategie optymalizacji wydajności w aplikacjach Next.js.

Edge Runtime w Next.js

Czym jest Edge Runtime?

Edge Runtime to lekkie środowisko wykonawcze, które umożliwia uruchamianie kodu bliżej użytkownika końcowego - na "brzegu" sieci - zamiast w centralnym centrum danych. Next.js umożliwia uruchamianie Route Handlerów i stron w Edge Runtime, co zapewnia:

  1. Mniejsze opóźnienia - kod wykonuje się bliżej użytkownika
  2. Szybszy czas pierwszego bajtu (TTFB) - szybsze rozpoczęcie przesyłania odpowiedzi
  3. Globalne skalowanie - automatyczne rozproszenie na całym świecie
  4. Mniejsze zużycie pamięci - dzięki lżejszemu runtime'owi

Różnice między Edge Runtime a Node.js Runtime

Warto rozumieć różnice między Edge Runtime a tradycyjnym środowiskiem Node.js:

CechaEdge RuntimeNode.js Runtime
Czas zimnego startuBardzo szybki (milisekundy)Wolniejszy (setki milisekund)
SkalowalnośćAutomatyczne, globalneWymaga konfiguracji
Dostęp do APIOgraniczony zestawPełne API Node.js
Rozmiar koduLimitowany (zazwyczaj 1-4 MB)Praktycznie nieograniczony
Dostęp do systemu plikówBrakPełny dostęp
Czas wykonania funkcjiOgraniczony (np. 50-60 ms)Dłuższy (minuty)
Typowe zastosowaniaAPI, strony z dynamicznym contentemSkomplikowane operacje, dostęp do baz danych

Konfiguracja Edge Runtime w Next.js

Aby uruchomić komponent strony lub Route Handler w Edge Runtime, używamy eksportu runtime w pliku:

// app/api/edge-route/route.ts
import { NextRequest } from 'next/server';

export const runtime = 'edge'; // Deklaracja Edge Runtime

export async function GET(request: NextRequest) {
  const { searchParams } = new URL(request.url);
  const query = searchParams.get('query') || 'Świat';

  // Obsługa żądania przy minimalnym opóźnieniu
  return Response.json({ message: `Witaj, ${query}!` });
}

Dla strony lub komponentu Layoutu:

// app/edge-page/page.tsx
import { cookies } from 'next/headers';

export const runtime = 'edge';

export default async function EdgePage() {
  const cookie = (await cookies()).get('theme')?.value || 'light';

  return (
    <div>
      <h1>Strona renderowana w Edge Runtime</h1>
      <p>Twój motyw: {cookie}</p>
    </div>
  );
}

Kiedy używać Edge Runtime?

Edge Runtime jest idealny dla:

  1. Dynamicznych personalizacji - np. geolokalizacji, preferencji użytkownika
  2. API proxy - przekazywanie żądań do innych serwisów z minimalnym opóźnieniem
  3. A/B testów - szybkie podejmowanie decyzji o wyświetlanej wersji
  4. Prostych dynamicznych stron - które nie wymagają złożonych operacji
  5. Międzynarodowych odbiorców - gdy opóźnienie sieci ma znaczenie

Przykład geolokalizacji w Edge Runtime:

// app/edge-geo/page.tsx
import { headers } from 'next/headers';

export const runtime = 'edge';

export default async function GeoPage() {
  const headersList = await headers();
  const countryCode = headersList.get('x-vercel-ip-country') || 'Unknown';
  const city = headersList.get('x-vercel-ip-city') || 'Unknown City';

  return (
    <div>
      <h1>Witaj, odwiedzający!</h1>
      <p>Wykryliśmy, że jesteś z: {city}, {countryCode}</p>
      {countryCode === 'PL' && (
        <p>Specjalna treść dla odwiedzających z Polski!</p>
      )}
    </div>
  );
}

Optymalizacja obrazów i mediów

Next.js oferuje wbudowane rozwiązania do optymalizacji mediów, które znacząco wpływają na wydajność aplikacji.

Next.js Image Component

Komponent Image w Next.js automatycznie optymalizuje obrazy, co zmniejsza rozmiar przesyłanych danych i poprawia metryki Web Vitals:

import Image from 'next/image';

export default function OptimizedImages() {
  return (
    <div>
      <h2>Optymalizowane obrazy w Next.js</h2>

      <Image
        src="/hero-image.jpg" // Ścieżka względna w katalogu public
        alt="Hero Image"
        width={1200}
        height={600}
        priority // Priorytet ładowania dla obrazów nad zagięciem
      />

      <Image
        src="https://cdn.example.com/remote-image.jpg" // Zdalny obraz
        alt="Remote Image"
        width={800}
        height={400}
        quality={80} // Regulacja jakości (1-100)
        placeholder="blur"
        blurDataURL="data:image/svg+xml;base64,..." // Opcjonalny placeholder podczas ładowania
      />
    </div>
  );
}

Kluczowe funkcje komponentu Image:

  1. Automatyczne rozmiary responsywne - generowanie różnych rozmiarów obrazu
  2. Lazy loading - obrazy ładowane tylko gdy są widoczne
  3. Konwersja do nowoczesnych formatów - WebP, AVIF
  4. Optymalizacja jakości - redukcja rozmiaru pliku przy zachowaniu jakości
  5. Placeholder podczas ładowania - rozmycie (blur) zapobiegające przesunięciom układu (CLS)

Optymalizacja czcionek

Next.js App Router wprowadza nowy system ładowania czcionek, który eliminuje problemy z migotaniem tekstu (CLS):

// app/layout.tsx
import { Inter, Roboto_Mono } from 'next/font/google';

// Konfiguracja czcionki zmiennej (variable font)
const inter = Inter({
  subsets: ['latin', 'latin-ext'],
  display: 'swap',
});

// Konfiguracja czcionki o stałej grubości
const robotoMono = Roboto_Mono({
  subsets: ['latin'],
  display: 'swap',
  weight: ['400', '700'],
});

export default function RootLayout({ children }) {
  return (
    <html lang="pl" className={`${inter.className} ${robotoMono.variable}`}>
      <body>{children}</body>
    </html>
  );
}

W komponencie możemy użyć zdefiniowanej czcionki:

// app/page.tsx
export default function Home() {
  return (
    <main>
      <h1 className={inter.className}>Nagłówek w czcionce Inter</h1>
      <code className="font-mono">// To będzie w Roboto Mono dzięki zmiennej CSS</code>
    </main>
  );
}

Strategie optymalizacji danych

React Server Components i redukcja bundle size

React Server Components (RSC) pozwalają znacząco zmniejszyć ilość JavaScript wysyłanego do przeglądarki:

// app/products/page.tsx - Server Component (domyślnie)
async function getProducts() {
  const res = await fetch('https://api.example.com/products');
  return res.json();
}

export default async function ProductsPage() {
  // Ten kod NIGDY nie jest wysyłany do klienta
  const products = await getProducts();
  const totalValue = products.reduce((sum, product) => sum + product.price, 0);

  return (
    <div>
      <h1>Produkty (wartość: {totalValue} zł)</h1>
      <ProductList products={products} />
    </div>
  );
}

Streaming i Suspense

Streaming umożliwia stopniowe przesyłanie UI, co przyspiesza Time to First Byte i poprawia interaktywność:

// app/dashboard/page.tsx
import { Suspense } from 'react';
import Loading from './loading';

// Komponenty ładujące dane niezależnie od siebie
import UserProfile from './UserProfile';
import RecentOrders from './RecentOrders';
import Analytics from './Analytics';

export default function Dashboard() {
  return (
    <div className="dashboard">
      <h1>Panel kontrolny</h1>

      <div className="dashboard-grid">
        {/* Szybciej ładujące się elementy będą widoczne od razu */}
        <Suspense fallback={<Loading section="profile" />}>
          <UserProfile />
        </Suspense>

        <Suspense fallback={<Loading section="orders" />}>
          <RecentOrders />
        </Suspense>

        <Suspense fallback={<Loading section="analytics" />}>
          <Analytics />
        </Suspense>
      </div>
    </div>
  );
}

Optymalizacja routingu i nawigacji

Prefetching i Parallel Routes

Next.js App Router automatycznie prefetchuje linki widoczne w widoku, co można dodatkowo kontrolować:

import Link from 'next/link';

export default function Navigation() {
  return (
    <nav>
      {/* Domyślny prefetch */}
      <Link href="/products">Produkty</Link>

      {/* Wyłączony prefetch */}
      <Link href="/heavy-page" prefetch={false}>Ciężka strona</Link>

      {/* Prefetch tylko nagłówków (dla dynamicznych stron) */}
      <Link href="/blog/article-123">Artykuł</Link>
    </nav>
  );
}

Parallel Routes umożliwiają ładowanie wielu sekcji strony niezależnie od siebie:

// app/layout.tsx
export default function Layout({ children, sidebar }) {
  return (
    <div className="layout">
      <aside className="sidebar">
        {sidebar}
      </aside>
      <main>
        {children}
      </main>
    </div>
  );
}

// app/@sidebar/page.tsx - ładowany niezależnie
export default function Sidebar() {
  return <div>Zawartość sidebara</div>;
}

// app/page.tsx - główna zawartość
export default function Home() {
  return <div>Główna zawartość</div>;
}

Route Handlers i optymalizacja API

Route Handlers mogą być zoptymalizowane pod kątem wydajności, szczególnie w połączeniu z Edge Runtime:

// app/api/optimized/route.ts
import { NextResponse } from 'next/server';

export const runtime = 'edge';

export async function GET() {
  // Stosowanie CORS dla optymalizacji preflightów
  const response = NextResponse.json({ data: 'wartość' });

  response.headers.set('Access-Control-Allow-Origin', '*');
  response.headers.set('Access-Control-Allow-Methods', 'GET, OPTIONS');
  response.headers.set('Access-Control-Allow-Headers', 'Content-Type');

  // Ustawienie Cache-Control dla browsera
  response.headers.set(
    'Cache-Control',
    'public, max-age=60, s-maxage=3600, stale-while-revalidate=600'
  );

  return response;
}

Zaawansowane techniki optymalizacji

Dobre praktyki dla funkcji generateStaticParams

Funkcja generateStaticParams służy do generowania statycznych wersji stron z parametrami:

// app/products/[category]/[id]/page.tsx
export async function generateStaticParams() {
  // Pobierz tylko niezbędne dane dla generowania ścieżek
  const categories = await fetch('https://api.example.com/categories').then(r => r.json());

  // Generuj kombinacje parametrów dla najważniejszych stron
  const paths = [];

  for (const category of categories) {
    // Pobierz tylko top produkty dla każdej kategorii
    const topProducts = await fetch(
      `https://api.example.com/categories/${category.id}/top-products`
    ).then(r => r.json());

    for (const product of topProducts) {
      paths.push({
        category: category.slug,
        id: product.id.toString(),
      });
    }
  }

  return paths;
}

export default async function ProductPage({ params }) {
  const { category, id } = await params;
  // Strona produktu...
}

Optymalizacja polega na:

  1. Generowaniu tylko najważniejszych parametrów (np. najpopularniejsze produkty)
  2. Minimalizacji liczby zapytań podczas budowania
  3. Odpowiednim cachowaniu danych używanych do generowania parametrów

Optymalizacja stylów i CSS

Next.js obsługuje różne strategie ładowania CSS, które można optymalizować:

// app/products/[id]/page.tsx
import './product-page.css'; // Globalny CSS dla tej trasy

// CSS Modules dla komponentu
import styles from './ProductDetails.module.css';

// Styled JSX (wbudowana opcja)
function ProductColorChoice() {
  return (
    <div className="color-selector">
      <style jsx>{`
        .color-selector {
          display: flex;
          gap: 8px;
        }
        .color-option {
          width: 24px;
          height: 24px;
          border-radius: 50%;
          cursor: pointer;
        }
      `}</style>
      <div className="color-option" style={{ backgroundColor: 'red' }} />
      <div className="color-option" style={{ backgroundColor: 'blue' }} />
    </div>
  );
}

export default async function ProductPage({ params }) {
  return (
    <div className={styles.productContainer}>
      <h1 className={styles.productTitle}>Szczegóły produktu {(await params).id}</h1>
      <ProductColorChoice />
    </div>
  );
}

Optymalizacja CSS:

  1. CSS Modules dla izolacji stylów komponentów
  2. Automatyczne usuwanie nieużywanego CSS (tree-shaking)
  3. Grupowanie CSS w chunki zgodnie z trasami aplikacji

Wykorzystanie HTTP/2 i HTTP/3

Hosting Next.js na platformach obsługujących nowoczesne protokoły HTTP/2 i HTTP/3 zapewnia lepszą wydajność dzięki:

  1. Multipleksowaniu zapytań - wiele zapytań przez jedno połączenie
  2. Kompresji nagłówków - mniejsze narzuty komunikacji
  3. Server Push - serwer może wysyłać zasoby zanim klient o nie poprosi

Nie wymaga to zmian w kodzie, ale odpowiedniej konfiguracji serwera lub wyboru platformy hostingowej (np. Vercel, Netlify, Cloudflare Pages).

Narzędzia analizy i poprawy wydajności

Next.js Analytics i Web Vitals

Next.js oferuje wbudowane metryki Web Vitals, które możemy śledzić:

// instrumentation.ts (w katalogu głównym)
export function register() {
  if (typeof window !== 'undefined') {
    // Rozwiązanie działa tylko po stronie klienta
    import('web-vitals').then(({ onCLS, onFID, onLCP, onTTFB }) => {
      onCLS(metric => sendAnalyticsEvent('CLS', metric));
      onFID(metric => sendAnalyticsEvent('FID', metric));
      onLCP(metric => sendAnalyticsEvent('LCP', metric));
      onTTFB(metric => sendAnalyticsEvent('TTFB', metric));
    });
  }
}

function sendAnalyticsEvent(name, metric) {
  const body = JSON.stringify({
    name,
    value: metric.value,
    page: window.location.pathname,
    id: metric.id,
  });

  // Wysyłka do własnego API
  navigator.sendBeacon('/api/analytics', body);
}

Audyt i analiza bundle size

Analiza rozmiaru bundla jest kluczowa dla wydajności. Next.js oferuje wbudowaną analizę bundla:

next build --analyze

Możemy też użyć bardziej zaawansowanych narzędzi jak @next/bundle-analyzer:

// next.config.js
const withBundleAnalyzer = require('@next/bundle-analyzer')({
  enabled: process.env.ANALYZE === 'true',
});

module.exports = withBundleAnalyzer({
  // Konfiguracja Next.js
});

Następnie uruchamiamy:

ANALYZE=true npm run build

Security Best Practices w Next.js

W Metropolii Quantum roku 2150, bezpieczeństwo to nie opcja - to konieczność. Każda luka w systemie może być wykorzystana przez cyberprzestępców czy wrogie korporacje. W tej sekcji omówimy najważniejsze praktyki zabezpieczania aplikacji Next.js, które chronią zarówno dane użytkowników, jak i integralność całego systemu.

CSRF Protection (Cross-Site Request Forgery)

CSRF to atak, w którym złośliwa strona wykorzystuje uwierzytelnioną sesję użytkownika do wykonania nieautoryzowanych akcji. Next.js oferuje wbudowane mechanizmy ochrony, szczególnie w Server Actions.

Implementacja CSRF Protection

// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function middleware(request: NextRequest) {
  // Weryfikacja Origin header dla mutacji
  if (request.method !== 'GET' && request.method !== 'HEAD') {
    const origin = request.headers.get('origin');
    const host = request.headers.get('host');

    // Sprawdź czy Origin odpowiada hostowi
    if (origin && !origin.includes(host || '')) {
      return new NextResponse('Forbidden', { status: 403 });
    }
  }

  return NextResponse.next();
}

export const config = {
  matcher: '/api/:path*'
};

CSRF Token dla formularzy

// lib/csrf.ts
import { cookies } from 'next/headers';
import crypto from 'crypto';

export async function generateCSRFToken(): Promise<string> {
  const token = crypto.randomBytes(32).toString('hex');
  const cookieStore = await cookies();

  cookieStore.set('csrf-token', token, {
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production',
    sameSite: 'strict',
    maxAge: 60 * 60 // 1 godzina
  });

  return token;
}

export async function verifyCSRFToken(token: string): Promise<boolean> {
  const cookieStore = await cookies();
  const storedToken = cookieStore.get('csrf-token')?.value;

  return storedToken === token;
}

// app/actions.ts
'use server';

import { verifyCSRFToken } from '@/lib/csrf';

export async function submitForm(formData: FormData) {
  const csrfToken = formData.get('csrf-token') as string;

  if (!await verifyCSRFToken(csrfToken)) {
    throw new Error('Invalid CSRF token');
  }

  // Przetwarzanie formularza...
}

// app/my-form/page.tsx
import { generateCSRFToken } from '@/lib/csrf';
import { submitForm } from '@/app/actions';

export default async function MyFormPage() {
  const csrfToken = await generateCSRFToken();

  return (
    <form action={submitForm}>
      <input type="hidden" name="csrf-token" value={csrfToken} />
      {/* Pozostałe pola formularza */}
      <button type="submit">Wyślij</button>
    </form>
  );
}

XSS Prevention (Cross-Site Scripting)

XSS to atak, w którym napastnik wstrzykuje złośliwy kod JavaScript do aplikacji. Next.js i React oferują wbudowaną ochronę, ale warto znać dodatkowe techniki.

Domyślna ochrona React

React automatycznie escapuje wszystkie wartości renderowane w JSX:

// Bezpieczne - React automatycznie escapuje
function UserProfile({ username }: { username: string }) {
  // Nawet jeśli username = "<script>alert('xss')</script>"
  // React wyświetli to jako tekst, nie wykona
  return <div>Witaj, {username}!</div>;
}

Uważaj na dangerouslySetInnerHTML

// NIEBEZPIECZNE - może wykonać złośliwy kod
function DangerousComponent({ html }: { html: string }) {
  return <div dangerouslySetInnerHTML={{ __html: html }} />;
}

// BEZPIECZNE - użyj biblioteki do sanityzacji
import DOMPurify from 'isomorphic-dompurify';

function SafeComponent({ html }: { html: string }) {
  const sanitized = DOMPurify.sanitize(html, {
    ALLOWED_TAGS: ['p', 'strong', 'em', 'a', 'ul', 'ol', 'li'],
    ALLOWED_ATTR: ['href', 'target']
  });

  return <div dangerouslySetInnerHTML={{ __html: sanitized }} />;
}

Content Security Policy (CSP)

CSP to mechanizm zabezpieczający przed XSS poprzez określenie, jakie źródła kodu są zaufane:

// next.config.js
const ContentSecurityPolicy = `
  default-src 'self';
  script-src 'self' 'unsafe-eval' 'unsafe-inline' https://trusted-cdn.com;
  style-src 'self' 'unsafe-inline' https://fonts.googleapis.com;
  img-src 'self' data: https: blob:;
  font-src 'self' https://fonts.gstatic.com;
  connect-src 'self' https://api.example.com;
  frame-ancestors 'none';
`;

const securityHeaders = [
  {
    key: 'Content-Security-Policy',
    value: ContentSecurityPolicy.replace(/\s{2,}/g, ' ').trim()
  }
];

module.exports = {
  async headers() {
    return [
      {
        source: '/:path*',
        headers: securityHeaders
      }
    ];
  }
};

Lub przez middleware:

// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function middleware(request: NextRequest) {
  const response = NextResponse.next();

  const csp = [
    "default-src 'self'",
    "script-src 'self' 'unsafe-eval' 'unsafe-inline'",
    "style-src 'self' 'unsafe-inline'",
    "img-src 'self' data: https:",
    "font-src 'self' data:",
    "connect-src 'self' https://api.example.com"
  ].join('; ');

  response.headers.set('Content-Security-Policy', csp);

  return response;
}

Rate Limiting - ochrona przed nadużyciami

Rate limiting chroni aplikację przed atakami typu DDoS i nadużyciami API. Możemy zaimplementować to w Next.js Middleware:

// lib/rate-limit.ts
import { LRUCache } from 'lru-cache';

type RateLimitOptions = {
  interval: number; // czas w milisekundach
  uniqueTokenPerInterval: number; // maksymalna liczba unikalnych tokenów
};

export function rateLimit(options: RateLimitOptions) {
  const tokenCache = new LRUCache({
    max: options.uniqueTokenPerInterval || 500,
    ttl: options.interval || 60000
  });

  return {
    check: (limit: number, token: string): { success: boolean; remaining: number } => {
      const tokenCount = (tokenCache.get(token) as number[]) || [0];

      if (tokenCount[0] === 0) {
        tokenCache.set(token, [1]);
        return { success: true, remaining: limit - 1 };
      }

      const currentCount = tokenCount[0];

      if (currentCount >= limit) {
        return { success: false, remaining: 0 };
      }

      tokenCache.set(token, [currentCount + 1]);
      return { success: true, remaining: limit - currentCount - 1 };
    }
  };
}

// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { rateLimit } from '@/lib/rate-limit';

const limiter = rateLimit({
  interval: 60 * 1000, // 1 minuta
  uniqueTokenPerInterval: 500
});

export async function middleware(request: NextRequest) {
  // Użyj IP jako identyfikatora
  const ip = request.ip ?? 'anonymous';

  try {
    const { success, remaining } = limiter.check(10, ip); // 10 requestów na minutę

    if (!success) {
      return new NextResponse('Too Many Requests', {
        status: 429,
        headers: {
          'X-RateLimit-Limit': '10',
          'X-RateLimit-Remaining': '0',
          'X-RateLimit-Reset': new Date(Date.now() + 60000).toISOString()
        }
      });
    }

    const response = NextResponse.next();
    response.headers.set('X-RateLimit-Limit', '10');
    response.headers.set('X-RateLimit-Remaining', remaining.toString());

    return response;
  } catch (error) {
    return new NextResponse('Internal Server Error', { status: 500 });
  }
}

export const config = {
  matcher: '/api/:path*'
};

Rate Limiting dla Server Actions

// lib/rate-limit-server-action.ts
import { cookies } from 'next/headers';

const rateLimitStore = new Map<string, { count: number; resetAt: number }>();

export async function checkRateLimit(
  action: string,
  limit: number = 10,
  windowMs: number = 60000
): Promise<boolean> {
  const cookieStore = await cookies();
  const sessionId = cookieStore.get('session-id')?.value || 'anonymous';
  const key = `${sessionId}:${action}`;

  const now = Date.now();
  const record = rateLimitStore.get(key);

  if (!record || now > record.resetAt) {
    rateLimitStore.set(key, {
      count: 1,
      resetAt: now + windowMs
    });
    return true;
  }

  if (record.count >= limit) {
    return false;
  }

  record.count++;
  return true;
}

// app/actions.ts
'use server';

import { checkRateLimit } from '@/lib/rate-limit-server-action';

export async function sensitiveAction(data: FormData) {
  const allowed = await checkRateLimit('sensitive-action', 5, 60000);

  if (!allowed) {
    throw new Error('Rate limit exceeded. Please try again later.');
  }

  // Wykonaj akcję...
}

Secure Headers (HSTS, X-Frame-Options, etc.)

Odpowiednie nagłówki HTTP to fundament bezpieczeństwa aplikacji webowych:

// next.config.js
const securityHeaders = [
  {
    key: 'X-DNS-Prefetch-Control',
    value: 'on'
  },
  {
    key: 'Strict-Transport-Security',
    value: 'max-age=63072000; includeSubDomains; preload'
  },
  {
    key: 'X-Frame-Options',
    value: 'SAMEORIGIN'
  },
  {
    key: 'X-Content-Type-Options',
    value: 'nosniff'
  },
  {
    key: 'X-XSS-Protection',
    value: '1; mode=block'
  },
  {
    key: 'Referrer-Policy',
    value: 'strict-origin-when-cross-origin'
  },
  {
    key: 'Permissions-Policy',
    value: 'camera=(), microphone=(), geolocation=()'
  }
];

module.exports = {
  async headers() {
    return [
      {
        source: '/:path*',
        headers: securityHeaders
      }
    ];
  }
};

Lub przez middleware dla większej kontroli:

// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function middleware(request: NextRequest) {
  const response = NextResponse.next();

  // HSTS - wymusza HTTPS
  response.headers.set(
    'Strict-Transport-Security',
    'max-age=31536000; includeSubDomains'
  );

  // X-Frame-Options - ochrona przed clickjacking
  response.headers.set('X-Frame-Options', 'SAMEORIGIN');

  // X-Content-Type-Options - zapobiega MIME sniffing
  response.headers.set('X-Content-Type-Options', 'nosniff');

  // X-XSS-Protection - dodatkowa ochrona przed XSS
  response.headers.set('X-XSS-Protection', '1; mode=block');

  // Referrer-Policy - kontrola informacji w nagłówku Referer
  response.headers.set('Referrer-Policy', 'strict-origin-when-cross-origin');

  // Permissions-Policy - kontrola dostępu do API przeglądarki
  response.headers.set(
    'Permissions-Policy',
    'camera=(), microphone=(), geolocation=(), payment=()'
  );

  return response;
}

Bezpieczeństwo API Routes i Server Actions

Walidacja input w Server Actions

// app/actions.ts
'use server';

import { z } from 'zod';
import { revalidatePath } from 'next/cache';

const CreatePostSchema = z.object({
  title: z.string().min(3).max(100),
  content: z.string().min(10).max(5000),
  tags: z.array(z.string()).max(5).optional()
});

export async function createPost(formData: FormData) {
  // Walidacja danych wejściowych
  const rawData = {
    title: formData.get('title'),
    content: formData.get('content'),
    tags: formData.getAll('tags')
  };

  const validation = CreatePostSchema.safeParse(rawData);

  if (!validation.success) {
    return {
      error: 'Validation failed',
      issues: validation.error.issues
    };
  }

  const { title, content, tags } = validation.data;

  // Weryfikacja autentykacji
  const session = await getServerSession();
  if (!session?.user) {
    return { error: 'Unauthorized' };
  }

  // Sanityzacja HTML (jeśli pozwalamy na formatowanie)
  const sanitizedContent = sanitizeHtml(content);

  try {
    const post = await db.post.create({
      data: {
        title,
        content: sanitizedContent,
        tags,
        authorId: session.user.id
      }
    });

    revalidatePath('/blog');

    return { success: true, post };
  } catch (error) {
    console.error('Failed to create post:', error);
    return { error: 'Failed to create post' };
  }
}

Bezpieczne API Routes

// app/api/users/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { getServerSession } from 'next-auth';
import { z } from 'zod';

const QuerySchema = z.object({
  page: z.coerce.number().min(1).default(1),
  limit: z.coerce.number().min(1).max(100).default(10)
});

export async function GET(request: NextRequest) {
  try {
    // Weryfikacja autentykacji
    const session = await getServerSession();
    if (!session) {
      return NextResponse.json(
        { error: 'Unauthorized' },
        { status: 401 }
      );
    }

    // Walidacja query parameters
    const { searchParams } = new URL(request.url);
    const validation = QuerySchema.safeParse({
      page: searchParams.get('page'),
      limit: searchParams.get('limit')
    });

    if (!validation.success) {
      return NextResponse.json(
        { error: 'Invalid parameters', issues: validation.error.issues },
        { status: 400 }
      );
    }

    const { page, limit } = validation.data;

    // Bezpieczne query do bazy danych
    const users = await db.user.findMany({
      skip: (page - 1) * limit,
      take: limit,
      select: {
        id: true,
        name: true,
        email: true,
        // NIE zwracaj hasła ani innych wrażliwych danych
      }
    });

    return NextResponse.json({ users });
  } catch (error) {
    console.error('API Error:', error);
    // NIE zwracaj szczegółów błędów w produkcji
    return NextResponse.json(
      { error: 'Internal server error' },
      { status: 500 }
    );
  }
}

Dodatkowe best practices

1. Bezpieczne przechowywanie sekretów

// .env.local (NIGDY nie commituj do repo!)
DATABASE_URL="postgresql://..."
NEXTAUTH_SECRET="super-secret-key"
API_KEY="secret-api-key"

// app/config.ts
const requiredEnvVars = [
  'DATABASE_URL',
  'NEXTAUTH_SECRET',
  'API_KEY'
] as const;

// Walidacja obecności zmiennych środowiskowych przy starcie
requiredEnvVars.forEach((varName) => {
  if (!process.env[varName]) {
    throw new Error(`Missing required environment variable: ${varName}`);
  }
});

export const config = {
  database: {
    url: process.env.DATABASE_URL!
  },
  auth: {
    secret: process.env.NEXTAUTH_SECRET!
  },
  api: {
    key: process.env.API_KEY!
  }
} as const;

2. Bezpieczne cookies

// lib/cookies.ts
import { cookies } from 'next/headers';

export async function setSecureCookie(name: string, value: string) {
  const cookieStore = await cookies();

  cookieStore.set(name, value, {
    httpOnly: true, // Niedostępne dla JavaScript
    secure: process.env.NODE_ENV === 'production', // Tylko HTTPS w produkcji
    sameSite: 'strict', // Ochrona przed CSRF
    maxAge: 60 * 60 * 24 * 7, // 7 dni
    path: '/'
  });
}

3. Logging i monitoring

// lib/logger.ts
export function logSecurityEvent(event: {
  type: 'auth_failure' | 'rate_limit' | 'csrf_violation' | 'xss_attempt';
  ip: string;
  userAgent: string;
  details?: any;
}) {
  const logEntry = {
    timestamp: new Date().toISOString(),
    ...event
  };

  // W produkcji wyślij do systemu monitoringu (Sentry, LogRocket, etc.)
  if (process.env.NODE_ENV === 'production') {
    // sendToMonitoring(logEntry);
  }

  console.warn('Security Event:', logEntry);
}

// middleware.ts
export function middleware(request: NextRequest) {
  const ip = request.ip ?? 'unknown';
  const userAgent = request.headers.get('user-agent') ?? 'unknown';

  // Loguj podejrzane aktywności
  if (isSuspicious(request)) {
    logSecurityEvent({
      type: 'csrf_violation',
      ip,
      userAgent,
      details: { url: request.url }
    });
  }

  return NextResponse.next();
}

Podsumowanie security best practices

W Metropolii Quantum bezpieczeństwo to proces ciągły, nie jednorazowa akcja. Kluczowe zasady:

  1. Nigdy nie ufaj inputowi użytkownika - zawsze waliduj i sanityzuj
  2. Używaj HTTPS wszędzie - wymuś przez HSTS
  3. Implementuj rate limiting - chroń przed nadużyciami
  4. Ustawiaj bezpieczne nagłówki - CSP, X-Frame-Options, etc.
  5. Chroń przed CSRF - weryfikuj Origin, używaj tokenów
  6. Zapobiegaj XSS - sanityzuj HTML, używaj CSP
  7. Bezpiecznie przechowuj sekrety - używaj zmiennych środowiskowych
  8. Loguj zdarzenia bezpieczeństwa - monitoruj podejrzane aktywności
  9. Regularnie aktualizuj zależności - łataj znane luki
  10. Stosuj principle of least privilege - minimalne uprawnienia

Podsumowanie: Najlepsze praktyki optymalizacji wydajności

Podsumowując, oto kluczowe zasady optymalizacji wydajności w Next.js:

  1. Używaj Edge Runtime dla dynamicznych, globalnych aplikacji wymagających niskiego opóźnienia
  2. Wykorzystuj React Server Components aby zmniejszyć ilość JS wysyłanego do klienta
  3. Optymalizuj obrazy za pomocą komponentu Image z Next.js
  4. Implementuj streaming z komponentem Suspense dla lepszej responsywności UI
  5. Zarządzaj cachowaniem na różnych poziomach (przeglądarka, CDN, serwer)
  6. Wykorzystuj prefetching dla szybszej nawigacji między stronami
  7. Monitoruj Web Vitals i ciągle optymalizuj krytyczne ścieżki renderowania
  8. Optymalizuj ładowanie fontów używając wbudowanego systemu fontów Next.js
  9. Eliminuj zbędny JavaScript poprzez analizę bundle size i usuwanie nieużywanych zależności
  10. Testuj na realnych urządzeniach i wolniejszych połączeniach, aby zidentyfikować problemy z wydajnością

Stosując te praktyki, możesz tworzyć aplikacje Next.js, które są zarówno funkcjonalne, jak i błyskawicznie szybkie, zapewniając użytkownikom doskonałe doświadczenia niezależnie od ich lokalizacji czy używanego urządzenia.

Kod do tej lekcji: App.tsx
import React, { useState } from 'react';

// Edge Runtime i optymalizacja performance w Next.js

interface RuntimeInfo {
  name: string;
  runtime: 'nodejs' | 'edge';
  latency: number; // ms
  coldStart: number; // ms
  regions: string[];
  features: string[];
}

const runtimes: RuntimeInfo[] = [
  {
    name: 'Node.js Runtime',
    runtime: 'nodejs',
    latency: 120,
    coldStart: 250,
    regions: ['us-east-1'],
    features: ['Pelny Node.js API', 'fs, crypto, stream', 'Brak limitu czasu', 'Duze pakiety'],
  },
  {
    name: 'Edge Runtime',
    runtime: 'edge',
    latency: 25,
    coldStart: 5,
    regions: ['Global CDN (30+ regionow)'],
    features: ['Web APIs', 'Szybki cold start', 'Niska latencja', 'Limit 25MB'],
  },
];

function LatencyBar({ value, max, color }: { value: number; max: number; color: string }) {
  return (
    <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
      <div style={{ flex: 1, height: 12, background: '#1a2744', borderRadius: 6, overflow: 'hidden' }}>
        <div style={{
          width: `${(value / max) * 100}%`, height: '100%',
          background: color, borderRadius: 6, transition: 'width 0.5s ease'
        }} />
      </div>
      <span style={{ color, fontSize: 12, minWidth: 50 }}>{value}ms</span>
    </div>
  );
}

export default function EdgeRuntimeDemo() {
  const [selected, setSelected] = useState<RuntimeInfo>(runtimes[1]);
  const [pings, setPings] = useState<number[]>([]);

  const simulatePing = () => {
    const base = selected.runtime === 'edge' ? 15 : 80;
    const jitter = Math.floor(Math.random() * 40);
    setPings(prev => [...prev.slice(-11), base + jitter]);
  };

  const avg = pings.length > 0 ? Math.round(pings.reduce((a, b) => a + b, 0) / pings.length) : 0;

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#e0e0e0', fontFamily: 'monospace' }}>
      <h1 style={{ color: '#64ffda' }}>Edge Runtime i Performance</h1>

      <div style={{ display: 'flex', gap: 12, margin: '16px 0' }}>
        {runtimes.map(r => (
          <button key={r.runtime} onClick={() => { setSelected(r); setPings([]); }} style={{
            flex: 1, background: selected.runtime === r.runtime ? '#1565c0' : '#0d1117',
            color: '#fff', border: `1px solid ${selected.runtime === r.runtime ? '#64ffda' : '#333'}`,
            borderRadius: 8, padding: 16, cursor: 'pointer', fontFamily: 'monospace', textAlign: 'left'
          }}>
            <div style={{ color: '#64ffda', fontWeight: 'bold' }}>{r.name}</div>
            <div style={{ fontSize: 11, color: '#888', marginTop: 4 }}>
              {r.runtime === 'edge' ? "export const runtime = 'edge'" : "// domyslny runtime"}
            </div>
          </button>
        ))}
      </div>

      <div style={{ background: '#0d1117', borderRadius: 8, padding: 16, marginBottom: 16 }}>
        <h3 style={{ color: '#64ffda', margin: '0 0 12px' }}>Metryki</h3>
        <div style={{ marginBottom: 8 }}>
          <span style={{ color: '#888', fontSize: 12 }}>Latencja:</span>
          <LatencyBar value={selected.latency} max={150} color="#4caf50" />
        </div>
        <div style={{ marginBottom: 8 }}>
          <span style={{ color: '#888', fontSize: 12 }}>Cold start:</span>
          <LatencyBar value={selected.coldStart} max={300} color="#ff9800" />
        </div>
        <div style={{ marginTop: 12 }}>
          <span style={{ color: '#888', fontSize: 12 }}>Regiony: </span>
          <span style={{ color: '#ce93d8', fontSize: 12 }}>{selected.regions.join(', ')}</span>
        </div>
        <div style={{ marginTop: 8 }}>
          <span style={{ color: '#888', fontSize: 12 }}>Funkcje:</span>
          <div style={{ display: 'flex', gap: 6, flexWrap: 'wrap', marginTop: 4 }}>
            {selected.features.map(f => (
              <span key={f} style={{
                background: '#1a2744', border: '1px solid #333', borderRadius: 4,
                padding: '2px 8px', fontSize: 11, color: '#aaa'
              }}>{f}</span>
            ))}
          </div>
        </div>
      </div>

      <button onClick={simulatePing} style={{
        background: '#4caf50', color: '#fff', border: 'none', borderRadius: 6,
        padding: '8px 16px', cursor: 'pointer', fontFamily: 'monospace'
      }}>
        Ping (symulacja)
      </button>
      {pings.length > 0 && (
        <span style={{ color: '#888', marginLeft: 12, fontSize: 12 }}>Srednia: {avg}ms</span>
      )}

      <div style={{ display: 'flex', gap: 4, flexWrap: 'wrap', marginTop: 12 }}>
        {pings.map((p, i) => (
          <div key={i} style={{
            background: p < 50 ? '#1b5e20' : p < 100 ? '#e65100' : '#b71c1c',
            borderRadius: 4, padding: '2px 6px', fontSize: 11
          }}>
            {p}ms
          </div>
        ))}
      </div>
    </div>
  );
}

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Partial Pre-rendering w Next.js 16 łączy:

  2. 2. Edge Runtime w Next.js oferuje:

To 2 z 9 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Utwórz system monitorowania wydajności: Core Web Vitals, render times, cache hit rates

  • Układanie w pionie

    Ułóż etapy obsługi żądania SSR w prawidłowej kolejności:

  • Układanie w pionie

    Ułóż etapy Streaming SSR w prawidłowej kolejności:

  • Układanie w poziomie

    Ułóż składnię wymuszającą statyczne renderowanie strony w Next.js:

  • Układanie w pionie

    Ułóż warstwy sprawdzania cache w Next.js w prawidłowej kolejności:

  • Układanie w poziomie

    Ułóż składnię fetch z wyłączonym cachowaniem w Next.js:

  • Układanie w pionie

    Ułóż etapy statycznej generacji stron w Next.js w prawidłowej kolejności:

  • Układanie w poziomie

    Ułóż składnię ustawienia czasu rewalidacji strony w Next.js:

  • Klikanie w kolejności

    Ułóż składnię revalidate w fetch

  • Klikanie w kolejności

    Ułóż eksport loading.tsx

  • Układanie w poziomie

    Ułóż elementy w prawidłowej kolejności: const Component → = dynamic( → () => imp

  • Układanie w pionie

    Ułóż elementy w prawidłowej kolejności: User request przychodzi → Server Compone

  • Układanie w poziomie

    Ułóż składnię wywołania rewalidacji po tagu w Next.js:

  • Edytor kodu

    Stwórz kompletny rendering engine: 1. Hybrid Rendering Strategy - implementuj intelligent routing między SSG/SSR/ISR 2. Server Components Architecture - zbuduj kompozycję server/client components 3. Streaming System - progresywne ładowanie z Suspense boundaries 4. Cache Strategy - multi-layer caching (Redis, Next.js, CDN, Edge) 5. Performance Optimization - code splitting, bundle analysis, lazy loading 6. SEO Engine - dynamic meta generation, structured data, sitemap 7. Real-time Updates - live data synchronization z Partial Prerendering 8. Error Boundaries - graceful error handling z fallback UI 9. Analytics Integration - performance monitoring, Core Web Vitals 10. Edge Computing - edge functions dla geographic optimization Użyj najnowszych funkcji: React 19.2, Next.js 16, Turbopack, Partial Prerendering (Cache Components).

  1. PytaniePartial Pre-rendering w Next.js 16 łączy:
  2. PytanieEdge Runtime w Next.js oferuje:
  3. Zadanie z kodemPraktyka: Utwórz system monitorowania wydajności: Core Web
  4. Ułóż w kolejnościPrzepływ żądania SSR
  5. PytanieData fetching w Server Components może używać:
  6. Ułóż w kolejnościPrzepływ Streaming SSR
  7. Ułóż w kolejnościSkładnia wymuszenia statycznego renderowania
  8. Ułóż w kolejnościWarstwy Data Cache w Next.js
  9. PytanieDomyślne cache'owanie fetch w Next.js
  10. Ułóż w kolejnościSkładnia fetch z wyłączonym cache
  11. Ułóż w kolejnościEtapy statycznej generacji stron
  12. PytanieDynamic rendering w Next.js występuje gdy:
  13. Ułóż w kolejnościSkładnia konfiguracji rewalidacji czasowej
  14. PytanieStrategie renderowania w Next.js
  15. PytanieRoute Segment Config w Next.js pozwala na:
  16. Kliknij w kolejnościSkładnia revalidate w fetch
  17. Kliknij w kolejnościEksport loading.tsx
  18. Ułóż w kolejnościKolejność: const Component → = dynamic( → ...
  19. Ułóż w kolejnościKolejność: User request przychodzi → Server Components
  20. PytanieForce-dynamic w Next.js powoduje:
  21. Ułóż w kolejnościSkładnia rewalidacji po tagu
  22. PytaniePierwsza warstwa cache w Next.js
  23. Zadanie z kodemSystem renderowania hybrydowego - krok po kroku

Przydatne artykuły