Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja
Implementacja Clerk w Next.js
W tej lekcji11
W nowoczesnych aplikacjach, niezawodna i bezpieczna obsługa uwierzytelniania oraz zarządzania użytkownikami stanowi fundament dobrego doświadczenia użytkownika. Clerk to kompleksowe rozwiązanie, które upraszcza ten aspekt tworzenia aplikacji, oferując gotowe komponenty i API do zarządzania tożsamością użytkowników w aplikacjach Next.js.
Czym jest Clerk?
Clerk to kompleksowa platforma zarządzania tożsamością (Identity-as-a-Service), zaprojektowana specjalnie pod kątem aplikacji Next.js i React. W przeciwieństwie do innych rozwiązań, Clerk oferuje pełny pakiet narzędzi do uwierzytelniania, zarządzania użytkownikami i zarządzania sesjami.
Główne zalety Clerk:
- Gotowe komponenty UI - pre-stylowane komponenty do logowania, rejestracji, weryfikacji dwustopniowej i więcej
- Natywne wsparcie dla Next.js App Router - zoptymalizowane do pracy z najnowszymi wersjami Next.js
- Wieloplatformowa obsługa - wsparcie dla wielu urządzeń i platform
- Wieloczynnikowe uwierzytelnianie - wbudowana obsługa 2FA
- Zarządzanie organizacjami i teamami - funkcje dla aplikacji B2B
- Zgodność z GDPR i innymi regulacjami - wbudowane mechanizmy ochrony prywatności
Instalacja i konfiguracja
Rozpocznijmy od instalacji pakietów Clerk w projekcie Next.js:
npm install @clerk/nextjs
# lub
yarn add @clerk/nextjs
# lub
pnpm add @clerk/nextjsKonfiguracja kluczy API
Po utworzeniu konta na clerk.com i nowej aplikacji, otrzymasz klucze API. Dodaj je do zmiennych środowiskowych w pliku .env.local:
NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_test_...
CLERK_SECRET_KEY=sk_test_...Jeśli korzystasz z GitHub lub innego systemu kontroli wersji, upewnij się, że plik .env.local jest dodany do .gitignore.
Owinięcie aplikacji w provider Clerk
Aby Clerk działał w całej aplikacji, musimy dodać ClerkProvider w głównym layoucie:
// app/layout.tsx
import { ClerkProvider } from '@clerk/nextjs';
export default function RootLayout({
children,
}: {
children: React.ReactNode;
}) {
return (
<ClerkProvider>
<html lang="pl">
<body>{children}</body>
</html>
</ClerkProvider>
);
}Konfiguracja ścieżek publicznych i chronionych
Ważnym krokiem jest określenie, które ścieżki są publiczne (dostępne dla niezalogowanych użytkowników), a które chronione (wymagające zalogowania). Można to zrobić za pomocą middleware:
// middleware.ts
import { authMiddleware } from "@clerk/nextjs";
export default authMiddleware({
publicRoutes: ["/", "/contact", "/about", "/api/public"],
});
export const config = {
matcher: ["/((?!.+\.[\w]+$|_next).*)", "/", "/(api|trpc)(.*)"],
};W powyższym przykładzie strony główna, kontaktowa i "o nas" są publiczne, a wszystkie inne wymagają zalogowania.
Komponenty uwierzytelniania
Clerk dostarcza gotowe komponenty do najczęstszych operacji związanych z uwierzytelnianiem.
SignIn i SignUp
Zaimplementowanie stron logowania i rejestracji jest bardzo proste:
// app/sign-in/[[...sign-in]]/page.tsx
import { SignIn } from "@clerk/nextjs";
export default function SignInPage() {
return (
<div className="flex justify-center items-center min-h-screen">
<SignIn
appearance={{
elements: {
formButtonPrimary: "bg-blue-500 hover:bg-blue-600 text-white",
footerActionLink: "text-blue-500 hover:text-blue-600"
}
}}
/>
</div>
);
}
// app/sign-up/[[...sign-up]]/page.tsx
import { SignUp } from "@clerk/nextjs";
export default function SignUpPage() {
return (
<div className="flex justify-center items-center min-h-screen">
<SignUp
appearance={{
elements: {
formButtonPrimary: "bg-blue-500 hover:bg-blue-600 text-white",
footerActionLink: "text-blue-500 hover:text-blue-600"
}
}}
/>
</div>
);
}Zwróć uwagę na wzorzec [[...sign-in]] w nazwie folderu - podwójne nawiasy kwadratowe oznaczają opcjonalny parametr catch-all, co pozwala Clerk obsługiwać różne stany uwierzytelniania.
UserButton - przycisk profilu użytkownika
Dodaj przycisk profilu użytkownika do nagłówka, który wyświetla menu z opcjami zarządzania kontem:
// components/Header.tsx
import { UserButton } from "@clerk/nextjs";
export function Header() {
return (
<header className="flex justify-between items-center p-4 bg-white shadow">
<div className="font-bold text-xl">Moja aplikacja</div>
<UserButton afterSignOutUrl="/" />
</header>
);
}Dostęp do informacji o użytkowniku
W komponentach po stronie klienta możemy użyć hooków Clerk, aby uzyskać informacje o zalogowanym użytkowniku:
// components/Profile.tsx
'use client';
import { useUser } from "@clerk/nextjs";
export function Profile() {
const { user, isLoaded } = useUser();
if (!isLoaded) {
return <div>Ładowanie...</div>;
}
return (
<div className="p-4">
<h1 className="text-2xl font-bold mb-4">Twój profil</h1>
<div className="mb-4">
<img
src={user?.imageUrl}
alt="Zdjęcie profilowe"
className="w-16 h-16 rounded-full"
/>
</div>
<p><strong>Imię:</strong> {user?.firstName}</p>
<p><strong>Nazwisko:</strong> {user?.lastName}</p>
<p><strong>Email:</strong> {user?.primaryEmailAddress?.emailAddress}</p>
</div>
);
}W komponentach po stronie serwera, możemy użyć funkcji pomocniczych:
// app/dashboard/page.tsx
import { currentUser } from "@clerk/nextjs";
export default async function DashboardPage() {
const user = await currentUser();
if (!user) {
return <div>Nie jesteś zalogowany</div>;
}
return (
<div className="p-4">
<h1 className="text-2xl font-bold mb-4">Panel użytkownika</h1>
<p>Witaj, {user.firstName}! Oto Twój panel użytkownika.</p>
</div>
);
}Zarządzanie organizacjami
Jedną z mocnych stron Clerk jest wbudowana obsługa organizacji (teamów), co jest szczególnie przydatne w aplikacjach B2B.
Komponent selekcji organizacji
// components/OrganizationSwitcher.tsx
import { OrganizationSwitcher } from "@clerk/nextjs";
export function OrgSwitcher() {
return (
<OrganizationSwitcher
appearance={{
elements: {
organizationSwitcherTrigger: "p-2 border rounded-md"
}
}}
/>
);
}Tworzenie nowej organizacji
// app/organizations/new/page.tsx
import { CreateOrganization } from "@clerk/nextjs";
export default function NewOrganizationPage() {
return (
<div className="flex justify-center items-center min-h-screen">
<CreateOrganization
appearance={{
elements: {
formButtonPrimary: "bg-blue-500 hover:bg-blue-600 text-white",
}
}}
/>
</div>
);
}Dostęp do danych organizacji
// app/dashboard/organization/page.tsx
import { currentUser, clerkClient } from "@clerk/nextjs";
import { redirect } from "next/navigation";
export default async function OrganizationDashboard() {
const user = await currentUser();
if (!user) {
return redirect("/sign-in");
}
// Pobierz aktywną organizację
const org = await clerkClient.organizations.getOrganization({
organizationId: user.organizationId || ""
});
if (!org) {
return (
<div className="p-4">
<h1 className="text-2xl font-bold mb-4">Nie wybrano organizacji</h1>
<p>Wybierz organizację, aby zobaczyć jej dashboard.</p>
</div>
);
}
return (
<div className="p-4">
<h1 className="text-2xl font-bold mb-4">Dashboard organizacji: {org.name}</h1>
<p>Członkowie: {org.membersCount}</p>
<p>Utworzono: {new Date(org.createdAt).toLocaleDateString()}</p>
</div>
);
}Zabezpieczanie API Routes
W Next.js App Router możemy łatwo zabezpieczać trasy API używając funkcji pomocniczych Clerk:
// app/api/protected/route.ts
import { auth } from "@clerk/nextjs";
import { NextResponse } from "next/server";
export async function GET() {
const { userId } = auth();
if (!userId) {
return new NextResponse(JSON.stringify({ error: "Unauthorized" }), {
status: 401,
headers: { "Content-Type": "application/json" }
});
}
return NextResponse.json({
message: "To są chronione dane tylko dla zalogowanych użytkowników"
});
}Dostosowywanie wyglądu
Clerk oferuje rozbudowane opcje dostosowywania wyglądu. Można to zrobić na trzy sposoby:
1. Za pomocą prop appearance
import { SignIn } from "@clerk/nextjs";
export default function SignInPage() {
return (
<SignIn
appearance={{
elements: {
formButtonPrimary: "bg-gradient-to-r from-blue-500 to-purple-500 text-white",
card: "shadow-xl border-0",
socialButtonsBlockButton: "border border-gray-300 hover:bg-gray-100"
}
}}
/>
);
}2. Za pomocą dostawcy wyglądu
// app/layout.tsx
import { ClerkProvider } from '@clerk/nextjs';
const appearance = {
elements: {
formButtonPrimary: "bg-blue-500 hover:bg-blue-600 text-white",
footerActionLink: "text-blue-500 hover:text-blue-600",
card: "shadow-md"
},
variables: {
colorPrimary: "#3B82F6"
}
};
export default function RootLayout({
children,
}: {
children: React.ReactNode;
}) {
return (
<ClerkProvider appearance={appearance}>
<html lang="pl">
<body>{children}</body>
</html>
</ClerkProvider>
);
}3. Za pomocą niestandardowych stylów CSS
Można również utworzyć plik CSS z własnymi stylami:
/* styles/clerk.css */
.cl-card {
border-radius: 12px;
box-shadow: 0 10px 25px rgba(0, 0, 0, 0.1);
}
.cl-formButtonPrimary {
background: linear-gradient(45deg, #3B82F6, #6366F1);
border-radius: 6px;
transition: transform 0.2s;
}
.cl-formButtonPrimary:hover {
transform: translateY(-2px);
}A następnie zaimportować do aplikacji:
// app/layout.tsx
import "../styles/clerk.css";Webhook i integracja z bazą danych
W większości aplikacji będziesz chciał synchronizować dane użytkowników Clerk z własną bazą danych. Najlepszym sposobem na to jest użycie webhooków:
Konfiguracja endpointu webhook
// app/api/webhooks/clerk/route.ts
import { WebhookEvent } from "@clerk/nextjs/server";
import { headers } from "next/headers";
import { NextResponse } from "next/server";
import { Webhook } from "svix";
export async function POST(req: Request) {
const WEBHOOK_SECRET = process.env.CLERK_WEBHOOK_SECRET;
if (!WEBHOOK_SECRET) {
throw new Error('Brak CLERK_WEBHOOK_SECRET');
}
// Pobierz nagłówki
const headerPayload = await headers();
const svix_id = headerPayload.get("svix-id");
const svix_timestamp = headerPayload.get("svix-timestamp");
const svix_signature = headerPayload.get("svix-signature");
if (!svix_id || !svix_timestamp || !svix_signature) {
return new NextResponse(JSON.stringify({ error: "Brak wymaganych nagłówków" }), {
status: 400
});
}
// Pobierz treść żądania
const payload = await req.json();
const body = JSON.stringify(payload);
// Zweryfikuj webhook
const webhook = new Webhook(WEBHOOK_SECRET);
let event: WebhookEvent;
try {
event = webhook.verify(body, {
"svix-id": svix_id,
"svix-timestamp": svix_timestamp,
"svix-signature": svix_signature,
}) as WebhookEvent;
} catch (err) {
console.error('Błąd weryfikacji webhooka:', err);
return new NextResponse(JSON.stringify({ error: "Nieprawidłowy podpis" }), {
status: 400
});
}
// Obsługa różnych typów zdarzeń
const { type } = event;
switch (type) {
case 'user.created': {
const { id, email_addresses, username, first_name, last_name } = event.data;
const primaryEmail = email_addresses?.[0]?.email_address;
// Tutaj dodaj logikę zapisania użytkownika w bazie danych
// Na przykład używając Prisma:
// await prisma.user.create({
// data: {
// clerkId: id,
// email: primaryEmail,
// username: username || "",
// firstName: first_name || "",
// lastName: last_name || ""
// }
// });
break;
}
case 'user.updated': {
const { id, email_addresses, username, first_name, last_name } = event.data;
const primaryEmail = email_addresses?.[0]?.email_address;
// Tutaj zaktualizuj użytkownika w bazie danych
break;
}
case 'user.deleted': {
const { id } = event.data;
// Tutaj usuń użytkownika z bazy danych
break;
}
// Obsłuż inne typy zdarzeń, takie jak organization.created, organization.updated, itp.
}
return NextResponse.json({ message: "Webhook odebrany" }, { status: 200 });
}Zaawansowane funkcje
Wieloczynnikowe uwierzytelnianie (2FA)
Clerk oferuje wbudowane wsparcie dla 2FA. Możesz włączyć tę funkcję w panelu administracyjnym Clerk.
Logowanie bezhasłowe
Możesz skonfigurować logowanie za pomocą linków magic link (bez hasła):
// app/sign-in/magic-link/page.tsx
import { SignIn } from "@clerk/nextjs";
export default function MagicLinkPage() {
return (
<div className="flex justify-center items-center min-h-screen">
<SignIn path="/sign-in/magic-link" />
</div>
);
}Wieloetapowe logowanie
Możesz utworzyć niestandardowy proces logowania z wieloma etapami:
// components/CustomSignIn.tsx
'use client';
import { useSignIn } from "@clerk/nextjs";
import { useState } from "react";
export function CustomSignIn() {
const { isLoaded, signIn, setActive } = useSignIn();
const [email, setEmail] = useState("");
const [password, setPassword] = useState("");
const [verificationCode, setVerificationCode] = useState("");
const [stage, setStage] = useState("email");
const [error, setError] = useState("");
if (!isLoaded) {
return <div>Ładowanie...</div>;
}
async function handleSubmitEmail(e: React.FormEvent) {
e.preventDefault();
setError("");
try {
await signIn.create({
identifier: email
});
await signIn.prepareFirstFactor({
strategy: "email_code",
email
});
setStage("verification");
} catch (err: any) {
setError(err.errors?.[0]?.message || "Wystąpił błąd");
}
}
async function handleVerifyCode(e: React.FormEvent) {
e.preventDefault();
setError("");
try {
const result = await signIn.attemptFirstFactor({
strategy: "email_code",
code: verificationCode
});
if (result.status === "complete") {
await setActive({ session: result.createdSessionId });
// Przekierowanie po zalogowaniu
window.location.href = "/dashboard";
}
} catch (err: any) {
setError(err.errors?.[0]?.message || "Kod nieprawidłowy");
}
}
return (
<div className="p-4 max-w-sm mx-auto">
<h1 className="text-2xl font-bold mb-4 text-center">Logowanie</h1>
{error && (
<div className="mb-4 p-2 bg-red-100 text-red-700 rounded-md">
{error}
</div>
)}
{stage === "email" ? (
<form onSubmit={handleSubmitEmail} className="space-y-4">
<div>
<label htmlFor="email" className="block mb-1">Email</label>
<input
id="email"
type="email"
value={email}
onChange={(e) => setEmail(e.target.value)}
required
className="w-full p-2 border rounded-md"
/>
</div>
<button
type="submit"
className="w-full bg-blue-500 text-white p-2 rounded-md hover:bg-blue-600"
>
Kontynuuj
</button>
</form>
) : (
<form onSubmit={handleVerifyCode} className="space-y-4">
<div>
<label htmlFor="code" className="block mb-1">Kod weryfikacyjny</label>
<input
id="code"
type="text"
value={verificationCode}
onChange={(e) => setVerificationCode(e.target.value)}
required
className="w-full p-2 border rounded-md"
/>
</div>
<button
type="submit"
className="w-full bg-blue-500 text-white p-2 rounded-md hover:bg-blue-600"
>
Weryfikuj
</button>
<button
type="button"
className="w-full text-blue-500 hover:text-blue-600"
onClick={() => setStage("email")}
>
Wróć
</button>
</form>
)}
</div>
);
}Wady i ograniczenia Clerk
Choć Clerk oferuje wiele korzyści, warto być świadomym kilku ograniczeń:
- Koszt - w przeciwieństwie do Auth.js, Clerk działa na modelu freemium i dla większych aplikacji wymaga płatnej subskrypcji
- Zależność od zewnętrznej usługi - dane uwierzytelniania są przechowywane na serwerach Clerk
- Mniejsza kontrola - masz mniejszą kontrolę nad implementacją szczegółów uwierzytelniania
- Kustomizacja - mimo wielu opcji dostosowywania, czasami natywne rozwiązanie może oferować więcej swobody
Kiedy wybrać Clerk zamiast Auth.js?
Przy podejmowaniu decyzji warto rozważyć następujące czynniki:
Wybierz Clerk, gdy:
- Potrzebujesz gotowego, kompletnego rozwiązania uwierzytelniania
- Chcesz szybko wdrożyć funkcje uwierzytelniania z minimalnym wysiłkiem
- Potrzebujesz zarządzania organizacjami i teamami
- Potrzebujesz zaawansowanych funkcji jak 2FA, magic links, etc.
- Nie chcesz zarządzać infrastrukturą uwierzytelniania
Wybierz Auth.js, gdy:
- Potrzebujesz większej kontroli nad procesem uwierzytelniania
- Preferujesz rozwiązanie open-source
- Nie chcesz polegać na zewnętrznym serwisie
- Masz ograniczony budżet dla większego projektu
- Musisz przechowywać dane uwierzytelniania we własnej bazie danych
Podsumowanie
Clerk to potężne narzędzie, które może znacząco przyspieszyć implementację uwierzytelniania w aplikacjach Next.js. Oferuje bogaty zestaw funkcji, które mogłyby wymagać tygodni pracy do samodzielnej implementacji. Dla wielu zespołów deweloperskich oszczędność czasu i gotowe rozwiązania bezpieczeństwa przeważają nad kosztami i mniejszą kontrolą.
Jednak wybór między Clerk, Auth.js, czy własnym rozwiązaniem uwierzytelniania powinien być oparty na konkretnych wymaganiach projektu, dostępnym budżecie i potrzebach biznesowych.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Demo: Clerk w Next.js
interface ClerkComponent {
name: string; icon: string; description: string; code: string;
category: 'ui' | 'hook' | 'middleware' | 'config';
}
const components: ClerkComponent[] = [
{ name: '<SignIn />', icon: 'K', category: 'ui',
description: 'Gotowy komponent logowania z OAuth, email i haslem',
code: "import { SignIn } from '@clerk/nextjs';\n\nexport default function SignInPage() {\n return <SignIn redirectUrl=\"/dashboard\" />;\n}" },
{ name: '<SignUp />', icon: 'R', category: 'ui',
description: 'Komponent rejestracji z weryfikacja email',
code: "import { SignUp } from '@clerk/nextjs';\n\nexport default function SignUpPage() {\n return <SignUp />;\n}" },
{ name: '<UserButton />', icon: 'U', category: 'ui',
description: 'Awatar z menu (profil, wylogowanie)',
code: "import { UserButton } from '@clerk/nextjs';\n\nfunction Navbar() {\n return <UserButton afterSignOutUrl=\"/\" />;\n}" },
{ name: 'useUser()', icon: 'H', category: 'hook',
description: 'Hook do danych zalogowanego uzytkownika',
code: "import { useUser } from '@clerk/nextjs';\n\nfunction Profile() {\n const { user, isLoaded, isSignedIn } = useUser();\n if (!isLoaded) return <div>Loading...</div>;\n return <h1>Welcome, {user.firstName}!</h1>;\n}" },
{ name: 'useAuth()', icon: 'A', category: 'hook',
description: 'Hook do stanu auth i tokenow',
code: "import { useAuth } from '@clerk/nextjs';\n\nfunction ApiCall() {\n const { getToken, userId } = useAuth();\n // const token = await getToken();\n}" },
{ name: 'clerkMiddleware()', icon: 'M', category: 'middleware',
description: 'Middleware do ochrony tras na edge',
code: "import { clerkMiddleware, createRouteMatcher } from '@clerk/nextjs/server';\n\nconst isProtected = createRouteMatcher(['/dashboard(.*)']);\n\nexport default clerkMiddleware((auth, req) => {\n if (isProtected(req)) auth().protect();\n});" },
{ name: 'ClerkProvider', icon: 'P', category: 'config',
description: 'Provider opakowujacy aplikacje',
code: "import { ClerkProvider } from '@clerk/nextjs';\n\nexport default function RootLayout({ children }) {\n return (\n <ClerkProvider>\n <html><body>{children}</body></html>\n </ClerkProvider>\n );\n}" },
];
const catColors: Record<string, string> = { ui: '#3b82f6', hook: '#8b5cf6', middleware: '#f59e0b', config: '#10b981' };
function ClerkDemo() {
const [selected, setSelected] = useState(components[0]);
const [filter, setFilter] = useState('all');
const [setupStep, setSetupStep] = useState(0);
const setupSteps = [
{ title: 'Instalacja', cmd: 'npm install @clerk/nextjs' },
{ title: 'Env vars', cmd: 'NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_...\nCLERK_SECRET_KEY=sk_...' },
{ title: 'Provider', cmd: 'Opakuj <html> w <ClerkProvider>' },
{ title: 'Middleware', cmd: 'Utworz middleware.ts z clerkMiddleware()' },
{ title: 'Gotowe!', cmd: 'Uzyj <SignIn />, <UserButton />, useUser()' },
];
const filtered = filter === 'all' ? components : components.filter(c => c.category === filter);
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
<h1 style={{ color: '#64ffda', marginBottom: '8px' }}>Clerk - Auth w Next.js</h1>
<p style={{ color: '#8892b0', marginBottom: '24px' }}>Gotowe komponenty i hooki do uwierzytelniania</p>
<div style={{ background: '#1a1a2e', padding: '16px', borderRadius: '12px', border: '1px solid #333', marginBottom: '24px' }}>
<h3 style={{ color: '#64ffda', marginTop: 0, fontSize: '16px' }}>Setup</h3>
<div style={{ display: 'flex', gap: '8px', marginBottom: '12px', flexWrap: 'wrap' }}>
{setupSteps.map((s, i) => (
<button key={i} onClick={() => setSetupStep(i)} style={{
padding: '6px 12px', borderRadius: '6px', border: 'none', cursor: 'pointer', fontSize: '12px',
background: setupStep === i ? '#64ffda' : i < setupStep ? '#10b98130' : '#333',
color: setupStep === i ? '#0f0f23' : '#8892b0',
}}>{i + 1}. {s.title}</button>
))}
</div>
<pre style={{ background: '#0f0f23', padding: '12px', borderRadius: '6px', fontSize: '13px', color: '#f59e0b', margin: 0, whiteSpace: 'pre-wrap' }}>{setupSteps[setupStep].cmd}</pre>
</div>
<div style={{ display: 'flex', gap: '8px', marginBottom: '20px' }}>
{['all', 'ui', 'hook', 'middleware', 'config'].map(f => (
<button key={f} onClick={() => setFilter(f)} style={{
padding: '6px 14px', borderRadius: '6px', border: 'none', cursor: 'pointer',
background: filter === f ? '#64ffda' : '#1a1a2e', color: filter === f ? '#0f0f23' : '#8892b0',
}}>{f}</button>
))}
</div>
<div style={{ display: 'grid', gridTemplateColumns: '260px 1fr', gap: '20px' }}>
<div style={{ display: 'grid', gap: '8px', alignContent: 'start' }}>
{filtered.map(comp => (
<button key={comp.name} onClick={() => setSelected(comp)} style={{
padding: '12px', borderRadius: '8px', textAlign: 'left',
border: selected.name === comp.name ? '1px solid #64ffda' : '1px solid #333',
background: selected.name === comp.name ? '#1a2a3e' : '#1a1a2e', color: '#e0e0e0', cursor: 'pointer',
}}>
<code style={{ color: '#64ffda', fontSize: '14px' }}>{comp.name}</code>
<div><span style={{ fontSize: '11px', padding: '2px 6px', borderRadius: '4px', background: catColors[comp.category] + '30', color: catColors[comp.category] }}>{comp.category}</span></div>
</button>
))}
</div>
<div style={{ background: '#1a1a2e', padding: '20px', borderRadius: '12px', border: '1px solid #333' }}>
<h3 style={{ color: '#64ffda', margin: '0 0 8px' }}>{selected.name}</h3>
<span style={{ fontSize: '12px', color: catColors[selected.category] }}>{selected.category}</span>
<p style={{ color: '#8892b0', fontSize: '14px' }}>{selected.description}</p>
<pre style={{ background: '#0f0f23', padding: '16px', borderRadius: '8px', fontSize: '13px', color: '#e0e0e0', overflow: 'auto', lineHeight: 1.5, whiteSpace: 'pre-wrap' }}>{selected.code}</pre>
</div>
</div>
</div>
);
}
export default ClerkDemo;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. Co zapewnia Clerk jako rozwiązanie do autentykacji w Next.js?
2. Jaka jest fundamentalna różnica między uwierzytelnianiem (authentication) a autoryzacją (authorization)?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj cykl zarządzania sesją:
- Klikanie w kolejności
Ułóż ścieżkę callback URL w NextAuth:
- Układanie w poziomie
Ułóż składnię pobierania sesji serwerowej w NextAuth:
- Układanie w pionie
Uporządkuj proces hashowania hasła:
- Układanie w poziomie
Ułóż składnię weryfikacji tokena JWT:
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: Header (typ i algorytm) → Payload (claim
- Układanie w poziomie
Ułóż składnię sprawdzania sesji w middleware:
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: User authorization na provider → Authori
- Układanie w poziomie
Ułóż składnię porównywania hasła z bcrypt:
- Klikanie w kolejności
Ułóż etapy weryfikacji JWT tokena:
- Edytor kodu
Utwórz system logowania authentication events: logins, logouts, failed attempts, security events
- Klikanie w kolejności
Ułóż etapy OAuth authorization code flow:
Zadania po tej lekcji
- PytanieClerk - zarządzanie użytkownikami
- Ułóż w kolejnościCykl zarządzania sesją
- Kliknij w kolejnościŚcieżka callback NextAuth
- Ułóż w kolejnościSkładnia getServerSession w NextAuth
- Ułóż w kolejnościProces hashowania hasła
- PytanieUwierzytelnianie vs autoryzacja
- Ułóż w kolejnościSkładnia weryfikacji JWT
- Ułóż w kolejnościKolejność: Header (typ i algorytm) → Payload (claims/da
- Ułóż w kolejnościSkładnia sprawdzania sesji w middleware
- Ułóż w kolejnościKolejność: User authorization na provider → Authorizati
- Ułóż w kolejnościSkładnia porównywania hasła z bcrypt
- PytaniePierwszy krok w zabezpieczaniu aplikacji Next.js
- Kliknij w kolejnościEtapy weryfikacji JWT tokena
- Zadanie z kodemPraktyka: Utwórz system logowania authentication events:
- Kliknij w kolejnościEtapy OAuth authorization code flow