Kurs Next.js · Moduł 8: Deployment i produkcja

Projekt: Pełne wdrożenie aplikacji Next.js do produkcji

6 min czytania ·
W tej lekcji10

Witaj w finalnym projekcie modułu wdrażania! W Metropolii Quantum 2150 każdy system przechodzi przez rygorystyczny proces przygotowania do produkcji - od budowania i optymalizacji, przez konfigurację SEO, aż po monitoring i testowanie. W tym projekcie połączymy wszystkie umiejętności zdobyte w całym module, aby przejść przez pełny cykl wdrażania aplikacji Next.js.

Cel projektu

Twoim zadaniem jest przygotowanie kompletnej aplikacji Next.js do wdrożenia produkcyjnego. Projekt obejmuje wszystkie kluczowe aspekty, które omówiliśmy w tym module:

  1. Budowanie i optymalizacja (z lekcji o build i analyze)
  2. SEO i metadane (z lekcji o metadanych dynamicznych)
  3. Open Graph i social sharing (z lekcji o OG)
  4. Sitemap i robots.txt (z lekcji o mapach witryn)
  5. Web Analytics (z lekcji o analityce)
  6. Wdrażanie na platformy hostingowe (z lekcji o Vercel/Netlify)
  7. Zmienne środowiskowe i konfiguracja produkcyjna (z lekcji o env vars)
  8. CI/CD (z lekcji o automatyzacji)
  9. Monitoring (z lekcji o monitoringu)
  10. PWA i Service Workers (z lekcji o PWA)
  11. Preview Deployments i staging (z lekcji o środowiskach)

Krok 1: Konfiguracja next.config.js

Rozpocznij od pełnej konfiguracji Next.js z optymalizacjami produkcyjnymi:

// next.config.ts
import type { NextConfig } from 'next';
import withBundleAnalyzer from '@next/bundle-analyzer';

const config: NextConfig = {
  // Optymalizacja obrazów
  images: {
    formats: ['image/avif', 'image/webp'],
    remotePatterns: [
      {
        protocol: 'https',
        hostname: 'cdn.quantum-city.com',
        pathname: '/images/**',
      },
    ],
    minimumCacheTTL: 60 * 60 * 24 * 30, // 30 dni cache
  },

  // Kompresja
  compress: true,

  // Optymalizacja bundla
  experimental: {
    optimizePackageImports: ['lucide-react', '@quantum/ui'],
  },

  // Nagłówki bezpieczeństwa
  async headers() {
    return [
      {
        source: '/:path*',
        headers: [
          { 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: 'Strict-Transport-Security',
            value: 'max-age=63072000; includeSubDomains; preload',
          },
          {
            key: 'Permissions-Policy',
            value: 'camera=(), microphone=(), geolocation=()',
          },
        ],
      },
    ];
  },

  // Przekierowania
  async redirects() {
    return [
      {
        source: '/old-page',
        destination: '/new-page',
        permanent: true, // 301 redirect
      },
    ];
  },
};

const withAnalyzer = withBundleAnalyzer({
  enabled: process.env.ANALYZE === 'true',
});

export default withAnalyzer(config);

Krok 2: SEO i dynamiczne metadane

Skonfiguruj metadane dla każdej strony z wykorzystaniem Metadata API:

// app/layout.tsx
import type { Metadata } from 'next';

export const metadata: Metadata = {
  metadataBase: new URL('https://quantum-city.com'),
  title: {
    default: 'Quantum City - Portal Metropolii',
    template: '%s | Quantum City',
  },
  description: 'Oficjalny portal Metropolii Quantum 2150',
  openGraph: {
    type: 'website',
    locale: 'pl_PL',
    url: 'https://quantum-city.com',
    siteName: 'Quantum City',
    images: [
      {
        url: '/og-default.png',
        width: 1200,
        height: 630,
        alt: 'Quantum City',
      },
    ],
  },
  twitter: {
    card: 'summary_large_image',
    creator: '@QuantumCity',
  },
  robots: {
    index: true,
    follow: true,
    googleBot: {
      index: true,
      follow: true,
      'max-video-preview': -1,
      'max-image-preview': 'large',
      'max-snippet': -1,
    },
  },
};

// app/products/[id]/page.tsx - dynamiczne metadane
import type { Metadata } from 'next';

type Props = { params: Promise<{ id: string }> };

export async function generateMetadata({ params }: Props): Promise<Metadata> {
  const product = await fetch(
    `https://api.quantum-city.com/products/${(await params).id}`
  ).then(r => r.json());

  return {
    title: product.name,
    description: product.description,
    openGraph: {
      title: product.name,
      description: product.description,
      images: [{ url: product.imageUrl, width: 800, height: 600 }],
    },
  };
}

Krok 3: Sitemap i robots.txt

Wygeneruj dynamiczną mapę witryny:

// app/sitemap.ts
import { MetadataRoute } from 'next';

export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const baseUrl = 'https://quantum-city.com';

  // Pobierz dynamiczne strony
  const products = await fetch('https://api.quantum-city.com/products')
    .then(r => r.json());

  const posts = await fetch('https://api.quantum-city.com/blog')
    .then(r => r.json());

  const productPages = products.map((product: any) => ({
    url: `${baseUrl}/products/${product.slug}`,
    lastModified: new Date(product.updatedAt),
    changeFrequency: 'weekly' as const,
    priority: 0.8,
  }));

  const blogPages = posts.map((post: any) => ({
    url: `${baseUrl}/blog/${post.slug}`,
    lastModified: new Date(post.updatedAt),
    changeFrequency: 'monthly' as const,
    priority: 0.6,
  }));

  return [
    { url: baseUrl, lastModified: new Date(), changeFrequency: 'daily', priority: 1 },
    { url: `${baseUrl}/products`, lastModified: new Date(), changeFrequency: 'daily', priority: 0.9 },
    ...productPages,
    ...blogPages,
  ];
}

// app/robots.ts
import { MetadataRoute } from 'next';

export default function robots(): MetadataRoute.Robots {
  return {
    rules: [
      {
        userAgent: '*',
        allow: '/',
        disallow: ['/admin/', '/api/', '/dashboard/'],
      },
    ],
    sitemap: 'https://quantum-city.com/sitemap.xml',
  };
}

Krok 4: Web Analytics i monitoring

Zintegruj system analityki i monitoringu błędów:

// lib/analytics.ts
export function trackEvent(name: string, properties?: Record<string, any>) {
  if (typeof window === 'undefined') return;

  // Własna analityka
  fetch('/api/analytics', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ event: name, properties, timestamp: Date.now() }),
  }).catch(console.error);
}

// lib/monitoring.ts
export function initErrorMonitoring() {
  if (typeof window === 'undefined') return;

  window.addEventListener('error', (event) => {
    fetch('/api/errors', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        message: event.message,
        filename: event.filename,
        lineno: event.lineno,
        stack: event.error?.stack,
        url: window.location.href,
        timestamp: new Date().toISOString(),
      }),
    }).catch(console.error);
  });
}

Krok 5: CI/CD Pipeline

Skonfiguruj automatyczny pipeline wdrażania:

# .github/workflows/deploy.yml
name: Deploy to Production

on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - run: npm run lint
      - run: npm run type-check
      - run: npm test

  e2e:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - run: npm run build
      - name: Cypress E2E Tests
        uses: cypress-io/github-action@v6
        with:
          start: npm start
          wait-on: 'http://localhost:3000'
          browser: chrome

  deploy:
    needs: [test, e2e]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Deploy to Vercel
        run: npx vercel --prod --token=VERCEL_TOKEN

Krok 6: PWA i offline support

Dodaj funkcjonalność Progressive Web App:

// app/manifest.ts
import { MetadataRoute } from 'next';

export default function manifest(): MetadataRoute.Manifest {
  return {
    name: 'Quantum City Portal',
    short_name: 'QC Portal',
    description: 'Oficjalny portal Metropolii Quantum 2150',
    start_url: '/',
    display: 'standalone',
    background_color: '#0a0a1a',
    theme_color: '#64ffda',
    icons: [
      { src: '/icon-192.png', sizes: '192x192', type: 'image/png' },
      { src: '/icon-512.png', sizes: '512x512', type: 'image/png' },
    ],
  };
}

Krok 7: Testy E2E z Cypress

Napisz testy pokrywające krytyczne ścieżki użytkownika:

// cypress/e2e/production-readiness.cy.ts
describe('Production Readiness Check', () => {
  it('strona główna ładuje się poniżej 3 sekund', () => {
    cy.visit('/', { timeout: 3000 });
    cy.get('h1').should('be.visible');
  });

  it('SEO meta tagi są poprawne', () => {
    cy.visit('/');
    cy.get('head title').should('contain', 'Quantum City');
    cy.get('meta[name="description"]').should('have.attr', 'content');
  });

  it('nagłówki bezpieczeństwa są ustawione', () => {
    cy.request('/').then((response) => {
      expect(response.headers).to.have.property('x-frame-options');
      expect(response.headers).to.have.property('x-content-type-options');
    });
  });
});

Krok 8: Checklist przed wdrożeniem

Przed każdym wdrożeniem produkcyjnym przejdź przez te punkty kontrolne:

Wydajność

  • Komenda next build kończy się bez błędów
  • Rozmiar bundla JS poniżej 200KB (gzipped)
  • LCP poniżej 2.5 sekundy, CLS poniżej 0.1
  • Obrazy zoptymalizowane (WebP/AVIF)

SEO

  • Każda strona ma unikalne title i description
  • Open Graph tagi są poprawne
  • Sitemap.xml i robots.txt są wygenerowane

Bezpieczeństwo

  • Nagłówki bezpieczeństwa (HSTS, CSP, X-Frame-Options)
  • CSRF protection i rate limiting
  • Walidacja inputu z Zod

Monitoring

  • Error tracking skonfigurowany
  • Web Vitals monitorowane
  • Alerty na krytyczne błędy

CI/CD

  • Testy jednostkowe i E2E przechodzą
  • Linting i type-checking bez błędów
  • Automatyczny deploy po merge do main

Podsumowanie

W tym projekcie połączyłeś wszystkie kluczowe umiejętności wdrażania aplikacji Next.js do produkcji. Każdy z tych elementów jest niezbędny do stworzenia profesjonalnej, wydajnej i bezpiecznej aplikacji webowej.

Pamiętaj - w Metropolii Quantum 2150 nie ma miejsca na półśrodki. Każdy system musi być w pełni zoptymalizowany, zabezpieczony i monitorowany. Teraz jesteś gotowy, aby wdrożyć swoje aplikacje Next.js na najwyższym poziomie!

Kod do tej lekcji: App.tsx
import React, { useState } from 'react';

// Projekt: Pelne wdrozenie aplikacji Next.js do produkcji

interface ChecklistItem {
  id: string;
  label: string;
  category: string;
  done: boolean;
}

const initialChecklist: ChecklistItem[] = [
  { id: '1', label: 'next.config.js - optymalizacja obrazow i kompresja', category: 'Build', done: false },
  { id: '2', label: 'Naglowki bezpieczenstwa (HSTS, CSP, X-Frame-Options)', category: 'Build', done: false },
  { id: '3', label: 'Metadata API - title, description, OG tags', category: 'SEO', done: false },
  { id: '4', label: 'Dynamiczne metadane dla podstron', category: 'SEO', done: false },
  { id: '5', label: 'Sitemap.xml wygenerowany', category: 'SEO', done: false },
  { id: '6', label: 'Robots.txt skonfigurowany', category: 'SEO', done: false },
  { id: '7', label: 'Web Analytics zintegrowany', category: 'Monitoring', done: false },
  { id: '8', label: 'Error monitoring skonfigurowany', category: 'Monitoring', done: false },
  { id: '9', label: 'Web Vitals monitorowane', category: 'Monitoring', done: false },
  { id: '10', label: 'CI/CD pipeline skonfigurowany', category: 'Deploy', done: false },
  { id: '11', label: 'Testy E2E (Cypress) przechodza', category: 'Deploy', done: false },
  { id: '12', label: 'PWA manifest i Service Worker', category: 'Deploy', done: false },
  { id: '13', label: 'Wdrozenie na Vercel/Netlify', category: 'Deploy', done: false },
];

const categoryColors: Record<string, string> = {
  Build: '#64ffda',
  SEO: '#bb86fc',
  Monitoring: '#ff9800',
  Deploy: '#4caf50',
};

export default function DeploymentChecklist() {
  const [items, setItems] = useState(initialChecklist);

  const toggle = (id: string) => {
    setItems(prev => prev.map(item => item.id === id ? { ...item, done: !item.done } : item));
  };

  const total = items.length;
  const done = items.filter(i => i.done).length;
  const pct = Math.round((done / total) * 100);

  const categories = Array.from(new Set(items.map(i => i.category)));

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#fff', fontFamily: 'monospace' }}>
      <h1 style={{ color: '#64ffda', fontSize: 20, marginBottom: 4 }}>Production Deployment Checklist</h1>
      <p style={{ color: '#888', fontSize: 13, marginBottom: 16 }}>Quantum City - Next.js Deployment</p>

      <div style={{ background: '#151530', borderRadius: 8, padding: 16, marginBottom: 20 }}>
        <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: 8, fontSize: 13 }}>
          <span style={{ color: '#aaa' }}>Postep: {done}/{total}</span>
          <span style={{ color: pct === 100 ? '#4caf50' : '#64ffda' }}>{pct}%</span>
        </div>
        <div style={{ height: 10, background: '#1a2744', borderRadius: 5, overflow: 'hidden' }}>
          <div style={{ width: pct + '%', height: '100%', background: pct === 100 ? '#4caf50' : '#64ffda', borderRadius: 5, transition: 'width 0.4s ease' }} />
        </div>
        {pct === 100 && <p style={{ color: '#4caf50', marginTop: 8, fontSize: 14 }}>Aplikacja gotowa do wdrozenia!</p>}
      </div>

      {categories.map(cat => (
        <div key={cat} style={{ marginBottom: 16 }}>
          <h3 style={{ color: categoryColors[cat] || '#fff', fontSize: 14, marginBottom: 8 }}>{cat}</h3>
          {items.filter(i => i.category === cat).map(item => (
            <div key={item.id} onClick={() => toggle(item.id)} style={{
              display: 'flex', alignItems: 'center', gap: 10, padding: '8px 12px', marginBottom: 4,
              background: item.done ? '#1a3a2a' : '#151530', borderRadius: 6, cursor: 'pointer',
              border: '1px solid ' + (item.done ? '#4caf5044' : '#334'),
            }}>
              <span style={{ fontSize: 16 }}>{item.done ? '\u2705' : '\u2B1C'}</span>
              <span style={{ color: item.done ? '#888' : '#ccc', fontSize: 13, textDecoration: item.done ? 'line-through' : 'none' }}>
                {item.label}
              </span>
            </div>
          ))}
        </div>
      ))}
    </div>
  );
}

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. Projekt do wysłaniaProjekt wdrożenia produkcyjnego
  2. WideoPodsumowanie: Deployment i optymalizacja produkcyjna

Przydatne artykuły