Kurs JavaScript i React · Moduł 8: Zaawansowane wzorce React
Budowanie aplikacji produkcyjnej i Deployment na Vercel
W tej lekcji8
Nasza kosmiczna podróż przez React dobiega końca. Zbudowaliśmy nasz statek kosmiczny, testowaliśmy go, optymalizowaliśmy - teraz nadszedł czas, aby wypuścić go w przestrzeń międzygwiezdną. W tym module nauczysz się, jak przygotować swoją aplikację React do produkcji i wdrożyć ją na platformie Vercel, aby była dostępna dla użytkowników z całego świata.
Od kodu do produkcji - przygotowanie aplikacji
Proces przeniesienia aplikacji React ze środowiska deweloperskiego do produkcyjnego wymaga kilku ważnych kroków. Zanim wyślemy naszą aplikację w kosmos (internet), musimy ją odpowiednio przygotować.
Znaczenie budowania produkcyjnego
Kod, który piszemy podczas developmentu, nie jest optymalny do uruchomienia w przeglądarce użytkownika. Aplikacja produkcyjna powinna być:
- Zminimalizowana - usunięte białe znaki, komentarze i skrócone nazwy zmiennych
- Zoptymalizowana - łączenie wielu plików, usuwanie nieużywanego kodu (tree shaking)
- Skompresowana - mniejszy rozmiar do przesłania przez sieć
- Stabilna - pozbawiona komunikatów debugowania i narzędzi deweloperskich
Vite jako nowoczesne narzędzie do budowania aplikacji
Vite (francuski: "szybki") to nowoczesne narzędzie do budowania aplikacji frontendowych, które znacząco przyspiesza proces developmentu i produkcji. W przeciwieństwie do starszych narzędzi (jak Create React App), Vite wykorzystuje natywne moduły ES w przeglądarce podczas developmentu oraz Rollup do budowania produkcyjnego.
Główne zalety Vite:
- Błyskawiczny start serwera deweloperskiego
- Szybkie odświeżanie (Hot Module Replacement)
- Wydajne budowanie produkcyjne
- Wsparcie dla TypeScript, JSX, CSS, SCSS, Less i innych
- Minimalna konfiguracja przy jednoczesnej elastyczności
Proces budowania aplikacji produkcyjnej z Vite
1. Przygotowanie aplikacji do budowania
Przed budowaniem aplikacji produkcyjnej warto wykonać kilka kroków:
Sprawdzenie zależności
Upewnij się, że wszystkie zależności są aktualne i bezpieczne:
# Sprawdzenie przestarzałych pakietów
npm outdated
# Sprawdzenie pod kątem podatności bezpieczeństwa
npm audit
# Aktualizacja pakietów (jeśli to bezpieczne)
npm updateUsunięcie konsol i debuggerów
W kodzie produkcyjnym nie powinny znajdować się instrukcje console.log czy debugger. Możesz użyć pluginu do Babel lub ESLint, aby je automatycznie usunąć.
Dla Vite, możesz dodać plugin vite-plugin-remove-console:
npm install vite-plugin-remove-console --save-devI skonfigurować go w vite.config.js:
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import removeConsole from 'vite-plugin-remove-console';
export default defineConfig({
plugins: [
react(),
removeConsole()
],
});Ustawienie zmiennych środowiskowych
Vite obsługuje zmienne środowiskowe poprzez pliki .env. Możesz tworzyć różne pliki dla różnych środowisk:
.env- zmienne dla wszystkich środowisk.env.development- tylko dla developmentu.env.production- tylko dla produkcji
Zmienne muszą zaczynać się od prefiksu VITE_, aby były dostępne w kodzie:
# .env.production
VITE_API_URL=https://api.yourdomain.com/v1
VITE_ANALYTICS_ID=UA-123456789-1W kodzie używasz ich tak:
const apiUrl = import.meta.env.VITE_API_URL;2. Budowanie aplikacji produkcyjnej
Budowanie produkcyjne w Vite jest proste - wystarczy uruchomić komendę:
npm run buildTa komenda wykonuje kilka operacji:
- Transpiluje kod ES6+/TypeScript/JSX do formatu obsługiwanego przez przeglądarki
- Minimalizuje kod JavaScript i CSS
- Optymalizuje zasoby (obrazy, fonty)
- Generuje haszowane nazwy plików dla cache busting
- Tworzy bundle zoptymalizowany pod kątem produkcji
Wynikiem jest katalog dist (domyślnie) zawierający zbudowaną aplikację.
3. Testowanie buildu produkcyjnego lokalnie
Przed deploymentem warto sprawdzić, czy zbudowana aplikacja działa poprawnie. Vite dostarcza proste narzędzie do lokalnego serwowania buildu produkcyjnego:
npm run previewTa komenda uruchomi lokalny serwer serwujący zbudowaną aplikację z katalogu dist, pozwalając na sprawdzenie jej działania przed faktycznym wdrożeniem.
Deployment na Vercel
Vercel to platforma do deploymentu aplikacji frontendowych, która doskonale współpracuje z React, Next.js i innymi frameworkami. Oferuje globalną CDN, automatyczne deployments z repozytorium Git, HTTPS, oraz wiele innych funkcji.
Dlaczego Vercel?
- Zero-config - automatyczne wykrywanie frameworka i konfiguracja
- Globalna CDN - szybkie dostarczanie treści użytkownikom na całym świecie
- Darmowy tier - dla projektów osobistych i open-source
- Preview deployments - każdy pull request generuje osobny deployment
- Integracja z Git - automatyczny deployment przy każdym push
- Serverless functions - możliwość dodania backendu bez osobnego serwera
Krok po kroku: Deployment aplikacji Vite+React na Vercel
1. Przygotowanie repozytorium Git
Vercel integruje się z GitHubem, GitLabem i Bitbucket. Upewnij się, że Twój projekt jest przechowywany w jednym z tych serwisów:
# Jeśli jeszcze nie zainicjowałeś repozytorium
git init
# Dodaj pliki do repozytorium
git add .
# Utwórz commit
git commit -m "Przygotowanie do deploymentu"
# Dodaj zdalne repozytorium (zastąp URL swoim)
git remote add origin https://github.com/twój-username/twój-projekt.git
# Wypchnij zmiany
git push -u origin main2. Konfiguracja projektu na Vercel
Utwórz konto na Vercel - przejdź na vercel.com i zarejestruj się (najlepiej używając tego samego konta, co w serwisie Git)
Importuj projekt:
- Kliknij "Add New..." > "Project"
- Wybierz swoje repozytorium z listy
- Vercel automatycznie wykryje, że używasz Vite
Skonfiguruj projekt:
- Framework Preset: Vercel powinien automatycznie wykryć Vite
- Build Command: Domyślnie
npm run build(zostaw bez zmian) - Output Directory: Domyślnie
dist(zostaw bez zmian) - Environment Variables: Dodaj te same zmienne, co w
.env.production(bez prefiksuVITE_)
Kliknij "Deploy" i poczekaj na zakończenie procesu
3. Weryfikacja deploymentu
Po zakończeniu deploymentu Vercel pokaże stronę z podsumowaniem. Możesz:
- Odwiedzić swoją stronę pod automatycznie przydzielonym adresem (np.
twój-projekt.vercel.app) - Sprawdzić logi buildowania i deploymentu
- Skonfigurować własną domenę
Konfiguracja ciągłego deploymentu (CI/CD)
Vercel automatycznie skonfiguruje Continuous Deployment dla Twojego projektu:
- Każdy push do głównej gałęzi (zwykle
mainlubmaster) spowoduje deployment na środowisko produkcyjne - Każdy pull request wygeneruje unikalny "Preview Deployment", pozwalając na testowanie zmian przed włączeniem ich do głównej gałęzi
Ta integracja tworzy prosty i wydajny workflow:
- Pracujesz lokalnie nad nową funkcją
- Wysyłasz zmiany do gałęzi
feature/new-feature - Tworzysz Pull Request
- Vercel automatycznie tworzy Preview Deployment
- Testujesz zmiany w środowisku podobnym do produkcyjnego
- Po zatwierdzeniu, łączysz PR z główną gałęzią
- Vercel automatycznie aktualizuje środowisko produkcyjne
Optymalizacja deploymentu
1. Analiza wydajności
Vercel oferuje Analytics, które pomagają monitorować wydajność aplikacji w realnym świecie:
- Real Experience Score - ocena doświadczenia użytkowników
- Core Web Vitals - metryki takie jak LCP, FID i CLS
- Metryki po stronach - które części aplikacji są najwolniejsze
Aby włączyć Analytics:
- Przejdź do projektu na Vercel
- Kliknij zakładkę "Analytics"
- Kliknij "Enable Analytics"
2. Optymalizacja zasobów statycznych
Vite automatycznie optymalizuje zasoby podczas buildowania, ale warto pamiętać o kilku dodatkowych praktykach:
- Używaj nowoczesnych formatów obrazów - WebP zamiast JPEG/PNG
- Lazy loading - ładuj obrazy/komponenty tylko gdy są potrzebne
- Preload kluczowych zasobów - dodaj tagi
<link rel="preload">dla krytycznych zasobów
3. Edge Functions i Edge Middleware na Vercel
Dla bardziej zaawansowanych aplikacji, Vercel oferuje:
- Edge Functions - lekkie funkcje działające na globalnej sieci brzegowej
- Edge Middleware - kod uruchamiany przed każdym żądaniem
Przykład Edge Middleware do przekierowania użytkowników na podstawie ich lokalizacji:
// middleware.js
export default function middleware(request) {
const country = request.geo.country || 'US';
// Przekierowanie użytkowników z Polski na polską wersję strony
if (country === 'PL' && !request.nextUrl.pathname.startsWith('/pl')) {
return Response.redirect(new URL('/pl' + request.nextUrl.pathname, request.url));
}
}
export const config = {
matcher: ['/((?!api|_next/static|favicon.ico).*)'],
};Najlepsze praktyki produkcyjne
1. Monitorowanie błędów
Zintegruj narzędzie do monitorowania błędów jak Sentry lub LogRocket:
npm install @sentry/react// src/main.jsx
import React from 'react';
import ReactDOM from 'react-dom/client';
import * as Sentry from '@sentry/react';
import App from './App';
import './index.css';
if (import.meta.env.PROD) {
Sentry.init({
dsn: import.meta.env.VITE_SENTRY_DSN,
integrations: [new Sentry.BrowserTracing()],
tracesSampleRate: 0.5,
});
}
ReactDOM.createRoot(document.getElementById('root')).render(
<React.StrictMode>
<App />
</React.StrictMode>
);2. Kod dzielony (Code Splitting)
Podziel aplikację na mniejsze kawałki, ładowane na żądanie:
import { lazy, Suspense } from 'react';
// Zamiast: import Dashboard from './Dashboard';
const Dashboard = lazy(() => import('./Dashboard'));
function App() {
return (
<div>
<Suspense fallback={<div>Ładowanie...</div>}>
<Dashboard />
</Suspense>
</div>
);
}3. Progresywne aplikacje webowe (PWA)
Przekształć swoją aplikację React w PWA, dodając Service Worker i manifest:
npm install vite-plugin-pwa --save-dev// vite.config.js
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import { VitePWA } from 'vite-plugin-pwa';
export default defineConfig({
plugins: [
react(),
VitePWA({
registerType: 'autoUpdate',
includeAssets: ['favicon.ico', 'robots.txt', 'apple-touch-icon.png'],
manifest: {
name: 'Space Mission Control',
short_name: 'SpaceMission',
description: 'Aplikacja do zarządzania misjami kosmicznymi',
theme_color: '#ffffff',
icons: [
{
src: 'pwa-192x192.png',
sizes: '192x192',
type: 'image/png'
},
{
src: 'pwa-512x512.png',
sizes: '512x512',
type: 'image/png'
}
]
}
})
]
});Podsumowanie procesu od developmentu do wdrożenia
Cały proces tworzenia i wdrażania aplikacji React z Vite wygląda następująco:
Development
- Inicjalizacja projektu z Vite:
npm create vite@latest my-app --template react - Rozwój funkcjonalności w lokalnym środowisku:
npm run dev - Testowanie komponentów i funkcjonalności
- Inicjalizacja projektu z Vite:
Przygotowanie do produkcji
- Usunięcie konsol i debuggerów
- Konfiguracja zmiennych środowiskowych produkcyjnych
- Sprawdzenie i aktualizacja zależności
Budowanie
- Uruchomienie buildu produkcyjnego:
npm run build - Testowanie zbudowanej aplikacji:
npm run preview
- Uruchomienie buildu produkcyjnego:
Przygotowanie repozytorium
- Inicjalizacja repozytorium Git
- Commit i push do zdalnego repozytorium
Deployment na Vercel
- Połączenie z repozytorium Git
- Konfiguracja projektu
- Deployment
Post-deployment
- Konfiguracja domeny
- Włączenie Analytics
- Monitorowanie błędów
- Optymalizacja wydajności
Zarządzanie aplikacją w produkcji
Po wdrożeniu aplikacji, Twoje obowiązki jako dewelopera nie kończą się. Ważne jest dalsze:
- Monitorowanie wydajności i błędów - regularne sprawdzanie Vercel Analytics i narzędzi do śledzenia błędów
- Aktualizacje zależności - regularne aktualizowanie pakietów, szczególnie przy poprawkach bezpieczeństwa
- Wprowadzanie nowych funkcji - wykorzystanie workflow CI/CD do bezpiecznego wprowadzania zmian
- A/B testy - testowanie nowych funkcji na podzbiorze użytkowników przed pełnym wdrożeniem
Zakończenie kosmicznej podróży
Ukończyliśmy naszą kosmiczną podróż po React! Zaczynając od podstaw, stopniowo budowaliśmy coraz bardziej zaawansowane komponenty, aż do pełnej aplikacji gotowej do wdrożenia na platformie Vercel.
Pamiętaj, że podobnie jak eksploracja kosmosu, nauka React to niekończąca się podróż. Ecosystem React stale się rozwija, pojawiają się nowe biblioteki, narzędzia i wzorce. Bądź na bieżąco z dokumentacją, blogami i społecznością, aby Twoje umiejętności pozostawały aktualne.
Teraz, gdy Twój statek kosmiczny jest zbudowany, przetestowany i gotowy do lotu - to czas, aby podbić kosmos frontendowych aplikacji!
Kod do tej lekcji: App.jsx
import React from 'react';
// Deployment i budowanie aplikacji produkcyjnej
export default function App() {
return (
<div style={{
background: '#0d1b2a', minHeight: '100vh',
padding: '20px', fontFamily: 'Arial', color: '#e0e1dd'
}}>
<h1 style={{ color: '#ffd700', textAlign: 'center' }}>
Deployment na Vercel
</h1>
<div style={{
background: '#1b2838', borderRadius: '12px',
padding: '20px', maxWidth: '600px', margin: '20px auto',
border: '1px solid #2a3f5f'
}}>
<h2 style={{ color: '#00d4ff' }}>Kroki wdrozenia:</h2>
<ol style={{ color: '#e0e1dd', lineHeight: 1.8 }}>
<li>npm run build - budowanie produkcyjne</li>
<li>Weryfikacja katalogu build/</li>
<li>Deploy na Vercel/Netlify</li>
<li>Konfiguracja zmiennych srodowiskowych</li>
</ol>
</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. Jaka jest standardowa konwencja nazewnictwa Higher-Order Components?
2. Co robi React.lazy() i kiedy go stosujemy?
To 2 z 9 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż składnię hooka useCallback z zależnością:
- Edytor kodu
useReducer dla systemu alarmowego
- Układanie w pionie
Uporządkuj kroki implementacji code splitting w aplikacji React:
- Edytor kodu
Kompozycja providerów z hookami
- Klikanie w kolejności
Uporządkuj wzorzec Render Props:
- Układanie w poziomie
Ułóż składnię hooka useMemo z tablicą zależności:
- Układanie w pionie
Uporządkuj wzorce zarządzania stanem React od najprostszego do najbardziej złożonego:
- Układanie w pionie
Uporządkuj ewolucję zarządzania stanem w React:
- Klikanie w kolejności
Ułóż wzorzec Render Props z children jako funkcją:
Zadania po tej lekcji
- PytanieWprowadzenie: Konwencja nazewnictwa HOC
- Ułóż w kolejnościSkładnia useCallback
- Zadanie z kodemPraktyka: useReducer - system alarmowy
- Ułóż w kolejnościKorzyści z code splitting
- Zadanie z kodemPraktyka: Provider Composition
- Kliknij w kolejnościWprowadzenie: Render Props structure
- PytanieCode splitting z React.lazy
- PytanieZwracana wartość custom hooka
- Ułóż w kolejnościSkładnia useMemo
- PytanieWprowadzenie: HOC a modyfikacja oryginalnego komponentu
- Ułóż w kolejnościWzorce zarządzania stanem
- PytanieFallback w React.lazy i Suspense
- Ułóż w kolejnościEwolucja zarządzania stanem
- Pytanienpm run build
- PytanieKomunikacja dziecko-rodzic w React
- Kliknij w kolejnościWprowadzenie: Render Props - children as function
- PytanieNarzędzia monitorowania wydajności React
- PytanieWprowadzenie: Custom hooks - zasada kompozycji