Kurs Next.js · Moduł 5: Strategie renderowania
Edge Runtime i optymalizacja wydajności
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:
- Mniejsze opóźnienia - kod wykonuje się bliżej użytkownika
- Szybszy czas pierwszego bajtu (TTFB) - szybsze rozpoczęcie przesyłania odpowiedzi
- Globalne skalowanie - automatyczne rozproszenie na całym świecie
- 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:
| Cecha | Edge Runtime | Node.js Runtime |
|---|---|---|
| Czas zimnego startu | Bardzo szybki (milisekundy) | Wolniejszy (setki milisekund) |
| Skalowalność | Automatyczne, globalne | Wymaga konfiguracji |
| Dostęp do API | Ograniczony zestaw | Pełne API Node.js |
| Rozmiar kodu | Limitowany (zazwyczaj 1-4 MB) | Praktycznie nieograniczony |
| Dostęp do systemu plików | Brak | Pełny dostęp |
| Czas wykonania funkcji | Ograniczony (np. 50-60 ms) | Dłuższy (minuty) |
| Typowe zastosowania | API, strony z dynamicznym contentem | Skomplikowane 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:
- Dynamicznych personalizacji - np. geolokalizacji, preferencji użytkownika
- API proxy - przekazywanie żądań do innych serwisów z minimalnym opóźnieniem
- A/B testów - szybkie podejmowanie decyzji o wyświetlanej wersji
- Prostych dynamicznych stron - które nie wymagają złożonych operacji
- 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:
- Automatyczne rozmiary responsywne - generowanie różnych rozmiarów obrazu
- Lazy loading - obrazy ładowane tylko gdy są widoczne
- Konwersja do nowoczesnych formatów - WebP, AVIF
- Optymalizacja jakości - redukcja rozmiaru pliku przy zachowaniu jakości
- 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:
- Generowaniu tylko najważniejszych parametrów (np. najpopularniejsze produkty)
- Minimalizacji liczby zapytań podczas budowania
- 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:
- CSS Modules dla izolacji stylów komponentów
- Automatyczne usuwanie nieużywanego CSS (tree-shaking)
- 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:
- Multipleksowaniu zapytań - wiele zapytań przez jedno połączenie
- Kompresji nagłówków - mniejsze narzuty komunikacji
- 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 --analyzeMoż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 buildSecurity 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:
- Nigdy nie ufaj inputowi użytkownika - zawsze waliduj i sanityzuj
- Używaj HTTPS wszędzie - wymuś przez HSTS
- Implementuj rate limiting - chroń przed nadużyciami
- Ustawiaj bezpieczne nagłówki - CSP, X-Frame-Options, etc.
- Chroń przed CSRF - weryfikuj Origin, używaj tokenów
- Zapobiegaj XSS - sanityzuj HTML, używaj CSP
- Bezpiecznie przechowuj sekrety - używaj zmiennych środowiskowych
- Loguj zdarzenia bezpieczeństwa - monitoruj podejrzane aktywności
- Regularnie aktualizuj zależności - łataj znane luki
- Stosuj principle of least privilege - minimalne uprawnienia
Podsumowanie: Najlepsze praktyki optymalizacji wydajności
Podsumowując, oto kluczowe zasady optymalizacji wydajności w Next.js:
- Używaj Edge Runtime dla dynamicznych, globalnych aplikacji wymagających niskiego opóźnienia
- Wykorzystuj React Server Components aby zmniejszyć ilość JS wysyłanego do klienta
- Optymalizuj obrazy za pomocą komponentu
Imagez Next.js - Implementuj streaming z komponentem
Suspensedla lepszej responsywności UI - Zarządzaj cachowaniem na różnych poziomach (przeglądarka, CDN, serwer)
- Wykorzystuj prefetching dla szybszej nawigacji między stronami
- Monitoruj Web Vitals i ciągle optymalizuj krytyczne ścieżki renderowania
- Optymalizuj ładowanie fontów używając wbudowanego systemu fontów Next.js
- Eliminuj zbędny JavaScript poprzez analizę bundle size i usuwanie nieużywanych zależności
- 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. Partial Pre-rendering w Next.js 16 łączy:
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).
Zadania po tej lekcji
- PytaniePartial Pre-rendering w Next.js 16 łączy:
- PytanieEdge Runtime w Next.js oferuje:
- Zadanie z kodemPraktyka: Utwórz system monitorowania wydajności: Core Web
- Ułóż w kolejnościPrzepływ żądania SSR
- PytanieData fetching w Server Components może używać:
- Ułóż w kolejnościPrzepływ Streaming SSR
- Ułóż w kolejnościSkładnia wymuszenia statycznego renderowania
- Ułóż w kolejnościWarstwy Data Cache w Next.js
- PytanieDomyślne cache'owanie fetch w Next.js
- Ułóż w kolejnościSkładnia fetch z wyłączonym cache
- Ułóż w kolejnościEtapy statycznej generacji stron
- PytanieDynamic rendering w Next.js występuje gdy:
- Ułóż w kolejnościSkładnia konfiguracji rewalidacji czasowej
- PytanieStrategie renderowania w Next.js
- PytanieRoute Segment Config w Next.js pozwala na:
- Kliknij w kolejnościSkładnia revalidate w fetch
- Kliknij w kolejnościEksport loading.tsx
- Ułóż w kolejnościKolejność: const Component → = dynamic( → ...
- Ułóż w kolejnościKolejność: User request przychodzi → Server Components
- PytanieForce-dynamic w Next.js powoduje:
- Ułóż w kolejnościSkładnia rewalidacji po tagu
- PytaniePierwsza warstwa cache w Next.js
- Zadanie z kodemSystem renderowania hybrydowego - krok po kroku