Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja

Uwierzytelnianie i Autoryzacja w Next.js

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

  1. Podejście własne - budowanie systemu uwierzytelniania od podstaw
  2. Biblioteki i SDK - wykorzystanie gotowych rozwiązań jak NextAuth.js/Auth.js
  3. 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:

  1. OAuth - uwierzytelnianie przez dostawców zewnętrznych (Google, Facebook, GitHub itp.)
  2. Credentials - uwierzytelnianie przez własny system loginów i haseł
  3. 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:

  1. Bezpieczne przechowywanie haseł - zawsze używaj funkcji hashujących jak bcrypt, nigdy nie przechowuj haseł w postaci zwykłego tekstu
  2. HTTPS - wszystkie żądania uwierzytelniające powinny korzystać z HTTPS
  3. CSRF (Cross-Site Request Forgery) - Auth.js automatycznie zabezpiecza przed atakami CSRF
  4. Limity prób logowania - implementuj ograniczenia ilości nieudanych prób logowania
  5. Bezpieczne tokeny - upewnij się, że tokeny JWT są odpowiednio podpisane i mają rozsądny czas ważności
  6. 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ć:

  1. Wymagania projektu - jakie metody logowania są potrzebne?
  2. Docelowi użytkownicy - czy preferują logowanie społecznościowe, czy tradycyjne?
  3. Skalę aplikacji - czy potrzebny jest złożony system ról i uprawnień?
  4. 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. 1. Która z poznanych metod uwierzytelniania jest bezstanowa (stateless) i nie wymaga przechowywania sesji na serwerze?

  2. 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:

  1. PytanieMetoda bezstanowa (stateless)
  2. Ułóż w kolejnościEtapy dodawania uwierzytelniania do aplikacji
  3. PytanieOchrona tras przed renderowaniem
  4. Projekt do wysłaniaProjekt systemu uwierzytelniania
  5. WideoPodsumowanie: Uwierzytelnianie i autoryzacja w Next.js

Przydatne artykuły