Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja
Uwierzytelnianie i Autoryzacja w Next.js
W tej lekcji6
W świecie, gdzie dane osobowe i bezpieczny dostęp do zasobów są na wagę złota, uwierzytelnianie i autoryzacja stanowią fundamentalne aspekty każdej nowoczesnej aplikacji internetowej. Next.js, jako framework zorientowany na produkcyjne zastosowania, oferuje rozbudowane narzędzia i integracje umożliwiające implementację bezpiecznych systemów uwierzytelniania.
Podstawy uwierzytelniania
Uwierzytelnianie (authentication) to proces weryfikacji tożsamości użytkownika - odpowiada na pytanie "Kim jesteś?". Autoryzacja (authorization) natomiast określa, do jakich zasobów uwierzytelniony użytkownik ma dostęp - odpowiada na pytanie "Co możesz zrobić?".
W aplikacjach Next.js możemy zaimplementować uwierzytelnianie na różne sposoby:
- Podejście własne - budowanie systemu uwierzytelniania od podstaw
- Biblioteki i SDK - wykorzystanie gotowych rozwiązań jak NextAuth.js/Auth.js
- Zewnętrzne usługi - integracja z usługami jak Firebase Auth, Auth0, Supabase Auth
NextAuth.js / Auth.js
NextAuth.js (obecnie znany również jako Auth.js) to popularna, wszechstronna biblioteka do uwierzytelniania w aplikacjach Next.js. Jej największe zalety to:
- Obsługa wielu dostawców uwierzytelniania (Google, GitHub, Facebook, Twitter itp.)
- Wbudowana obsługa sesji i tokenów JWT
- Kompatybilność z API Routes i App Router
- Łatwa konfiguracja i minimalna ilość kodu boilerplate
Podstawowa konfiguracja Auth.js w App Router
Oto prosty przykład konfiguracji Auth.js w aplikacji z App Router:
// app/api/auth/[...nextauth]/route.ts
import NextAuth from "next-auth";
import GitHubProvider from "next-auth/providers/github";
import CredentialsProvider from "next-auth/providers/credentials";
const handler = NextAuth({
providers: [
GitHubProvider({
clientId: process.env.GITHUB_ID as string,
clientSecret: process.env.GITHUB_SECRET as string,
}),
CredentialsProvider({
name: 'Credentials',
credentials: {
username: { label: "Email", type: "email" },
password: { label: "Hasło", type: "password" }
},
async authorize(credentials) {
// Tutaj należy zaimplementować własną logikę weryfikacji danych logowania
// np. sprawdzenie w bazie danych
if (credentials?.username === "admin@example.com" && credentials?.password === "password") {
return { id: "1", name: "Admin", email: "admin@example.com" };
}
return null;
}
}),
],
pages: {
signIn: '/auth/signin',
signOut: '/auth/signout',
error: '/auth/error',
},
callbacks: {
async session({ session, token }) {
// Możemy tutaj dodać dodatkowe dane do sesji
return session;
},
async jwt({ token, user }) {
// Możemy tutaj dodać dodatkowe dane do tokenu JWT
if (user) {
token.role = user.role;
}
return token;
}
}
});
export { handler as GET, handler as POST };Strategie uwierzytelniania
Auth.js obsługuje trzy główne strategie uwierzytelniania:
- OAuth - uwierzytelnianie przez dostawców zewnętrznych (Google, Facebook, GitHub itp.)
- Credentials - uwierzytelnianie przez własny system loginów i haseł
- Email - uwierzytelnianie za pomocą linków wysyłanych na email (bezhasłowe)
Użycie komponentów klienckich do zarządzania sesją
W komponentach klienckich możemy korzystać z hooków dostarczanych przez Auth.js:
// app/components/login-button.tsx
'use client';
import { signIn, signOut, useSession } from "next-auth/react";
export function LoginButton() {
const { data: session, status } = useSession();
if (status === "loading") {
return <div>Ładowanie...</div>;
}
if (session) {
return (
<div>
<p>Zalogowano jako: {session.user?.name}</p>
<button onClick={() => signOut()}>Wyloguj się</button>
</div>
);
}
return <button onClick={() => signIn()}>Zaloguj się</button>;
}Provider sesji w układzie głównym
Aby używać useSession() w komponentach klienckich, musimy dodać SessionProvider do głównego układu aplikacji:
// app/providers.tsx
'use client';
import { SessionProvider } from "next-auth/react";
export function Providers({ children }: { children: React.ReactNode }) {
return <SessionProvider>{children}</SessionProvider>;
}
// app/layout.tsx
import { Providers } from "./providers";
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
<html lang="pl">
<body>
<Providers>{children}</Providers>
</body>
</html>
);
}Middleware do ochrony tras
Next.js pozwala używać middleware do zabezpieczania tras przed nieautoryzowanym dostępem. Oto przykład middleware, który sprawdza sesję użytkownika i przekierowuje na stronę logowania, jeśli sesja nie istnieje:
// middleware.ts
import { NextResponse } from 'next/server';
import { getToken } from 'next-auth/jwt';
import type { NextRequest } from 'next/server';
export async function middleware(request: NextRequest) {
const token = await getToken({ req: request });
// Ścieżki, które powinny być chronione
const protectedPaths = ['/dashboard', '/profile', '/settings'];
// Sprawdzamy, czy bieżąca ścieżka jest chroniona
const isProtectedPath = protectedPaths.some(path =>
request.nextUrl.pathname.startsWith(path)
);
if (isProtectedPath && !token) {
// Jeśli użytkownik próbuje uzyskać dostęp do chronionej ścieżki bez zalogowania,
// przekierowujemy go na stronę logowania
const loginUrl = new URL('/auth/signin', request.url);
loginUrl.searchParams.set('callbackUrl', request.nextUrl.pathname);
return NextResponse.redirect(loginUrl);
}
return NextResponse.next();
}
export const config = {
matcher: ['/dashboard/:path*', '/profile/:path*', '/settings/:path*'],
};Role i uprawnienia użytkowników
W bardziej złożonych aplikacjach często potrzebujemy implementować system ról i uprawnień. Możemy rozszerzyć domyślne mechanizmy Auth.js, aby obsługiwały role:
// Rozszerzamy typy dla Auth.js
declare module "next-auth" {
interface User {
role?: string;
}
interface Session {
user?: {
id?: string;
name?: string;
email?: string;
role?: string;
};
}
}
// W callbackach Auth.js
callbacks: {
async jwt({ token, user }) {
if (user) {
token.role = user.role;
}
return token;
},
async session({ session, token }) {
if (session.user) {
session.user.role = token.role as string;
}
return session;
}
}Następnie możemy stworzyć komponenty warunkowe bazujące na rolach:
// app/components/role-guard.tsx
'use client';
import { useSession } from "next-auth/react";
import { redirect } from "next/navigation";
interface RoleGuardProps {
children: React.ReactNode;
allowedRoles: string[];
}
export function RoleGuard({ children, allowedRoles }: RoleGuardProps) {
const { data: session, status } = useSession();
if (status === "loading") {
return <div>Sprawdzanie uprawnień...</div>;
}
if (!session || !session.user?.role || !allowedRoles.includes(session.user.role)) {
return <div>Brak dostępu. Wymagane uprawnienia: {allowedRoles.join(', ')}</div>;
}
return <>{children}</>;
}Bezpieczeństwo aplikacji
Implementując uwierzytelnianie, należy pamiętać o kilku kluczowych aspektach bezpieczeństwa:
- Bezpieczne przechowywanie haseł - zawsze używaj funkcji hashujących jak bcrypt, nigdy nie przechowuj haseł w postaci zwykłego tekstu
- HTTPS - wszystkie żądania uwierzytelniające powinny korzystać z HTTPS
- CSRF (Cross-Site Request Forgery) - Auth.js automatycznie zabezpiecza przed atakami CSRF
- Limity prób logowania - implementuj ograniczenia ilości nieudanych prób logowania
- Bezpieczne tokeny - upewnij się, że tokeny JWT są odpowiednio podpisane i mają rozsądny czas ważności
- Bezpieczne zmienne środowiskowe - tajne klucze i hasła przechowuj w zmiennych środowiskowych
Przykład implementacji limitów prób logowania
import { NextRequest, NextResponse } from 'next/server';
import { getToken } from 'next-auth/jwt';
// Prosta implementacja w pamięci (w produkcji należałoby użyć Redis lub innego store)
const loginAttempts = new Map<string, { count: number, lastAttempt: number }>();
export async function middleware(request: NextRequest) {
if (request.nextUrl.pathname === '/api/auth/callback/credentials') {
const ip = request.ip || 'unknown';
const currentAttempts = loginAttempts.get(ip) || { count: 0, lastAttempt: Date.now() };
// Resetuj licznik po 30 minutach
if (Date.now() - currentAttempts.lastAttempt > 30 * 60 * 1000) {
currentAttempts.count = 0;
}
// Jeśli przekroczono limit prób
if (currentAttempts.count >= 5) {
return new NextResponse(
JSON.stringify({ error: 'Zbyt wiele prób logowania. Spróbuj ponownie za 30 minut.' }),
{ status: 429 }
);
}
// Aktualizacja licznika
loginAttempts.set(ip, {
count: currentAttempts.count + 1,
lastAttempt: Date.now()
});
}
return NextResponse.next();
}Podsumowanie
Uwierzytelnianie i autoryzacja to kluczowe elementy każdej aplikacji webowej. Next.js wraz z Auth.js oferuje potężne narzędzia do implementacji bezpiecznych systemów uwierzytelniania, od prostych rozwiązań po złożone systemy z rolami i uprawnieniami.
Wybierając rozwiązanie uwierzytelniania dla swojej aplikacji Next.js, warto rozważyć:
- Wymagania projektu - jakie metody logowania są potrzebne?
- Docelowi użytkownicy - czy preferują logowanie społecznościowe, czy tradycyjne?
- Skalę aplikacji - czy potrzebny jest złożony system ról i uprawnień?
- Bezpieczeństwo - jakie środki bezpieczeństwa są niezbędne dla twojej aplikacji?
Odpowiednie podejście do uwierzytelniania i autoryzacji nie tylko zabezpiecza twoją aplikację, ale także poprawia doświadczenie użytkownika, budując zaufanie do twojego produktu.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Demo: Przeglad metod Auth i Authorization w Next.js
interface AuthMethod {
id: string; name: string; icon: string; category: 'authentication' | 'authorization';
pros: string[]; cons: string[]; useCase: string; difficulty: string;
code: string;
}
const methods: AuthMethod[] = [
{ id: 'session', name: 'Session Auth', icon: '[S]', category: 'authentication',
pros: ['Latwa implementacja', 'Mozliwosc uniewaznienia', 'Dane na serwerze'],
cons: ['Wymaga storage', 'Skalowanie', 'CSRF'],
useCase: 'Tradycyjne aplikacje webowe',
difficulty: 'easy',
code: 'const session = await getServerSession(authOptions);\nif (!session) redirect("/login");' },
{ id: 'jwt', name: 'JWT Tokens', icon: '[J]', category: 'authentication',
pros: ['Stateless', 'Skalowalne', 'Cross-domain'],
cons: ['Nie mozna uniewaznic', 'Rozmiar', 'Storage w przegladarce'],
useCase: 'API, mikroserwisy, SPA',
difficulty: 'medium',
code: 'const token = req.headers.authorization?.split(" ")[1];\nconst decoded = jwt.verify(token, SECRET);' },
{ id: 'oauth', name: 'OAuth 2.0', icon: '[O]', category: 'authentication',
pros: ['Bez hasel w bazie', 'Szybkie logowanie', 'Zaufani dostawcy'],
cons: ['Zaleznosc zewnetrzna', 'Konfiguracja', 'Prywatnosc'],
useCase: 'Logowanie przez Google, GitHub',
difficulty: 'medium',
code: 'providers: [\n GoogleProvider({ clientId, clientSecret }),\n]' },
{ id: 'rbac', name: 'RBAC', icon: '[R]', category: 'authorization',
pros: ['Przejrzysty model', 'Latwe zarzadzanie', 'Audytowalnosc'],
cons: ['Moze byc zbyt prosty', 'Role explosion'],
useCase: 'Aplikacje z typami uzytkownikow',
difficulty: 'easy',
code: 'if (session.user.role !== "admin")\n return redirect("/unauthorized");' },
{ id: 'middleware', name: 'Middleware', icon: '[M]', category: 'authorization',
pros: ['Centralne', 'Edge Runtime', 'Przed renderowaniem'],
cons: ['Ograniczone API', 'Brak dostepu do bazy'],
useCase: 'Ochrona tras, redirecty',
difficulty: 'easy',
code: 'export function middleware(req: NextRequest) {\n const token = req.cookies.get("token");\n if (!token) return NextResponse.redirect("/login");\n}' },
];
const diffColors: Record<string, string> = { easy: '#10b981', medium: '#f59e0b', hard: '#ef4444' };
function AuthOverview() {
const [filter, setFilter] = useState<'all' | 'authentication' | 'authorization'>('all');
const [selected, setSelected] = useState<AuthMethod | null>(null);
const filtered = methods.filter(m => filter === 'all' || m.category === filter);
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
<h1 style={{ color: '#64ffda', marginBottom: '8px' }}>Auth & Authorization - Przeglad</h1>
<p style={{ color: '#8892b0', marginBottom: '20px' }}>Porownanie metod uwierzytelniania i autoryzacji</p>
<div style={{ display: 'flex', gap: '8px', marginBottom: '20px' }}>
{(['all', 'authentication', 'authorization'] as const).map(f => (
<button key={f} onClick={() => setFilter(f)} style={{ padding: '8px 16px', borderRadius: '8px', border: 'none', cursor: 'pointer', background: filter === f ? '#64ffda' : '#1a1a2e', color: filter === f ? '#0f0f23' : '#8892b0', fontWeight: 'bold' }}>
{f === 'all' ? 'Wszystkie' : f}
</button>
))}
</div>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fill, minmax(250px, 1fr))', gap: '16px', marginBottom: '24px' }}>
{filtered.map(m => (
<div key={m.id} onClick={() => setSelected(m)} style={{
padding: '16px', borderRadius: '12px', cursor: 'pointer',
background: selected?.id === m.id ? '#1a2a3e' : '#1a1a2e',
border: selected?.id === m.id ? '1px solid #64ffda' : '1px solid #333',
}}>
<div style={{ fontSize: '20px', marginBottom: '8px' }}>{m.icon}</div>
<h3 style={{ color: '#64ffda', margin: '0 0 4px', fontSize: '16px' }}>{m.name}</h3>
<div style={{ display: 'flex', gap: '8px', marginBottom: '8px' }}>
<span style={{ fontSize: '11px', padding: '2px 6px', borderRadius: '4px', background: '#333', color: '#8892b0' }}>{m.category}</span>
<span style={{ fontSize: '11px', padding: '2px 6px', borderRadius: '4px', background: diffColors[m.difficulty] + '30', color: diffColors[m.difficulty] }}>{m.difficulty}</span>
</div>
<p style={{ fontSize: '13px', color: '#8892b0', margin: 0 }}>{m.useCase}</p>
</div>
))}
</div>
{selected && (
<div style={{ background: '#1a1a2e', padding: '20px', borderRadius: '12px', border: '1px solid #333' }}>
<h3 style={{ color: '#64ffda', marginTop: 0 }}>{selected.icon} {selected.name}</h3>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '16px', marginBottom: '16px' }}>
<div>
<h4 style={{ color: '#10b981', fontSize: '14px' }}>Zalety:</h4>
<ul style={{ fontSize: '13px', color: '#8892b0', paddingLeft: '20px', margin: 0 }}>{selected.pros.map((p, i) => <li key={i}>{p}</li>)}</ul>
</div>
<div>
<h4 style={{ color: '#ef4444', fontSize: '14px' }}>Wady:</h4>
<ul style={{ fontSize: '13px', color: '#8892b0', paddingLeft: '20px', margin: 0 }}>{selected.cons.map((c, i) => <li key={i}>{c}</li>)}</ul>
</div>
</div>
<pre style={{ background: '#0f0f23', padding: '12px', borderRadius: '6px', fontSize: '12px', color: '#64ffda', overflow: 'auto' }}>{selected.code}</pre>
</div>
)}
</div>
);
}
export default AuthOverview;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. Która z poznanych metod uwierzytelniania jest bezstanowa (stateless) i nie wymaga przechowywania sesji na serwerze?
2. Który mechanizm pozwala chronić trasy, zanim strona zostanie wyrenderowana?
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj etapy wdrażania uwierzytelniania i autoryzacji w aplikacji Next.js: