Kurs Vue.js · Moduł 12: Testy i wdrożenie

Projekt: Mars Mission Launch - Complete Production App

7 min czytania ·
W tej lekcji7

Finalna aplikacja gotowa do startu! Twój kod leci na Marsa!

Przez pięć lekcji składałeś procedurę startową z osobnych elementów: testy komponentów, testy logiki, E2E, build i wdrożenie. Każdy działał w swojej lekcji, ale prawdziwy projekt potrzebuje ich wszystkich naraz, w jednym repozytorium, spiętych tak, żeby żaden krok nie zależał od pamięci operatora. Ten projekt to kompletna konfiguracja produkcyjna galerii - przejdziemy przez nią plik po pliku.

Konfiguracja Vite gotowa do startu

Plik vite.config.js zaczyna się od trzech wtyczek: vue() kompiluje komponenty, ViteImageOptimizer kompresuje obrazy, a visualizer rysuje raport rozmiarów pakietów i od razu otwiera go w przeglądarce:

// vite.config.js - Production ready
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import { ViteImageOptimizer } from 'vite-plugin-image-optimizer'
import { visualizer } from 'rollup-plugin-visualizer'

export default defineConfig({
  plugins: [
    vue(),
    ViteImageOptimizer({
      jpg: { quality: 80 },
      png: { quality: 80 },
      webp: { quality: 80 }
    }),
    visualizer({
      open: true,
      gzipSize: true
    })
  ],

Wtyczki nie ruszają plików w src - pracują na tym, co wędruje do dist. Druga część pliku ustawia build: minifikator terser, podział na pakiety i port serwera deweloperskiego:

  // vite.config.js - dalszy ciąg defineConfig
  build: {
    outDir: 'dist',
    sourcemap: false,
    minify: 'terser',

    terserOptions: {
      compress: {
        drop_console: true,
        drop_debugger: true
      }
    },

    rolldownOptions: {
      output: {
        codeSplitting: {
          groups: [
            { name: 'vue-vendor', test: /node_modules[\\/](vue|@vue|vue-router|pinia)[\\/]/ },
            { name: 'utils', test: /node_modules[\\/]@vueuse[\\/]/ }
          ]
        }
      }
    }
  },

  server: {
    port: 3000,
    open: true
  }
})

Opcje drop_console i drop_debugger w terserOptions usuwają z kodu produkcyjnego wszystkie wywołania console.log i instrukcje debugger; pliki źródłowe zostają nietknięte. Terser trzeba doinstalować (npm install -D terser), a domyślny minifikator Vite 8, Oxc, zrobi to samo opcją dropConsole w build.rolldownOptions.output.minify.compress. Podział opisuje codeSplitting: każda grupa ma nazwę pakietu i test, czyli wyrażenie regularne dopasowywane do ścieżki modułu, w którym [\\/] łapie ukośnik i ukośnik wsteczny ścieżek Windows. Starsze konfiguracje z rollupOptions.output.manualChunks w formie obiektu przestały działać - Vite 8 przerywa na nich build.

Skrypty w package.json

Plik package.json zbiera polecenia procedury startowej w jednym miejscu - każdy etap pipeline wywoła później jeden z tych skryptów:

// package.json
{
  "name": "gallery-app",
  "version": "1.0.0",
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "preview": "vite preview",
    "test": "vitest",
    "test:ui": "vitest --ui",
    "test:coverage": "vitest --coverage",
    "lint": "eslint . --ext .vue,.js,.ts",
    "format": "prettier --write .",
    "type-check": "vue-tsc --noEmit",
    "deploy": "npm run build && vercel --prod"
  }
}

lint przegląda kod ESLintem, format porządkuje go Prettierem, a type-check uruchamia vue-tsc, czyli sprawdzanie typów TypeScript także w plikach .vue. deploy wysyła build poleceniem vercel --prod, równoważnym z vercel deploy --prod.

Lazy loading komponentów

Ciężki komponent, na przykład wykres telemetrii otwierany na żądanie, nie musi siedzieć w głównym pakiecie. Funkcja defineAsyncComponent z pakietu vue przyjmuje funkcję z dynamicznym import() i zwraca komponent pobierany przy pierwszym wyrenderowaniu:

import { defineAsyncComponent } from 'vue'

const TelemetryChart = defineAsyncComponent(() =>
  import('./components/TelemetryChart.vue')
)

Build wydzieli TelemetryChart.vue do osobnego pakietu, a w szablonie używasz go jak zwykłego komponentu. Trasom routera wystarczy samo () => import().

Pipeline CI/CD

Workflow dzieli pracę na trzy zadania (jobs). Pierwsze, test, rusza przy każdym pushu i pull requeście i przechodzi pełną kontrolę jakości:

# .github/workflows/ci.yml
name: CI/CD

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v7

      - name: Setup Node
        uses: actions/setup-node@v7
        with:
          node-version: 24
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Lint
        run: npm run lint

      - name: Type check
        run: npm run type-check

      - name: Run tests
        run: npm run test:coverage

      - name: Upload coverage
        uses: codecov/codecov-action@v7
        with:
          token: ${{ secrets.CODECOV_TOKEN }}

Kolejność jest celowa: najtańsze kontrole idą pierwsze. cache: 'npm' przechowuje paczki między uruchomieniami, a akcja Codecov wysyła raport pokrycia z tokenem z sekretów repozytorium. Zadanie build czeka na zielony test dzięki polu needs i zapisuje dist jako artefakt:

  build:
    runs-on: ubuntu-latest
    needs: test

    steps:
      - uses: actions/checkout@v7

      - name: Setup Node
        uses: actions/setup-node@v7
        with:
          node-version: 24
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Build
        run: npm run build

      - name: Upload build artifacts
        uses: actions/upload-artifact@v7
        with:
          name: dist
          path: dist

Artefakt to plik, który GitHub przechowuje między zadaniami. Wersje v3 akcji artefaktów przestały działać 30 stycznia 2025 roku, dlatego stare workflow kończą się dziś błędem. Ostatnie zadanie wdraża aplikację wyłącznie z gałęzi main, co sprawdza warunek if:

  deploy:
    runs-on: ubuntu-latest
    needs: build
    if: github.ref == 'refs/heads/main'

    steps:
      - uses: actions/checkout@v7

      - name: Download build artifacts
        uses: actions/download-artifact@v8
        with:
          name: dist
          path: dist

      - name: Deploy to Vercel
        uses: amondnet/vercel-action@v42
        with:
          vercel-token: ${{ secrets.VERCEL_TOKEN }}
          vercel-org-id: ${{ secrets.ORG_ID }}
          vercel-project-id: ${{ secrets.PROJECT_ID }}
          vercel-args: '--prod'

Pull requesty przechodzą więc testy i build bez wdrożenia. Pobrany artefakt przyda się przy hostingu statycznym, bo Vercel domyślnie buduje projekt u siebie, z przesłanego kodu.

Kapsuła Docker

Wersja kontenerowa to Dockerfile z poprzedniej lekcji z komentarzami i kontrolą HEALTHCHECK, która co 30 sekund sprawdza, czy nginx odpowiada:

# Dockerfile - Multi-stage build
FROM node:24-alpine AS builder

WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies (the build needs devDependencies too)
RUN npm ci

# Copy source
COPY . .

# Build
RUN npm run build

# Production stage
FROM nginx:alpine

# Copy build
COPY --from=builder /app/dist /usr/share/nginx/html

# Copy nginx config
COPY nginx.conf /etc/nginx/conf.d/default.conf

# Health check
HEALTHCHECK --interval=30s --timeout=3s \
  CMD wget --quiet --tries=1 --spider http://localhost/ || exit 1

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

Uważaj na częsty błąd: npm ci --only=production w etapie budowania pomija devDependencies, w których siedzi Vite, więc build by się nie udał. Do końcowego obrazu i tak trafia tylko dist.

Zoptymalizowany nginx

Konfiguracja serwera dokłada kompresję gzip, nagłówki bezpieczeństwa i osobne reguły cache:

# nginx.conf - Optimized
server {
  listen 80;
  server_name _;
  root /usr/share/nginx/html;
  index index.html;

  # Gzip
  gzip on;
  gzip_vary on;
  gzip_types text/plain text/css text/xml text/javascript
             application/x-javascript application/xml+rss
             application/javascript application/json;

  # Security headers
  add_header X-Frame-Options "SAMEORIGIN" always;
  add_header X-Content-Type-Options "nosniff" always;
  # Deprecated header: 0 disables the legacy XSS filter, use a Content-Security-Policy instead
  add_header X-XSS-Protection "0" always;

  # SPA routing
  location / {
    try_files $uri $uri/ /index.html;
  }

  # Cache static assets
  location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
    expires 1y;
    add_header Cache-Control "public, immutable";
  }

  # Don't cache index.html
  location = /index.html {
    add_header Cache-Control "no-cache, must-revalidate";
  }
}

index.html nie może trafić do długiego cache, bo wskazuje aktualne nazwy pakietów. X-XSS-Protection jest przestarzały i MDN zaleca zamiast niego Content-Security-Policy, stąd wartość 0. Pułapka: add_header z poziomu server nie przechodzi do bloków location z własnym add_header, więc tam nagłówki bezpieczeństwa trzeba powtórzyć.

Monitorowanie i SEO

Po starcie patrzysz na przyrządy: profilowanie wydajności w Vue DevTools pokaże zbyt częste renderowanie, Lighthouse audyt ładowania, a metryki Web Vitals (LCP, INP, CLS) doświadczenia prawdziwych użytkowników. SPA wysyła botom wyszukiwarek pusty index.html, a treść dorysowuje JavaScript. Google i Bing radzą sobie z prostymi aplikacjami, ale nie czekają na dane pobierane asynchronicznie, więc pełny HTML da botom dopiero SSR albo SSG, najprościej z Nuxt - poznasz go w Laboratorium Kwantowym. Przed ręcznym startem zachowaj kolejność pipeline: lint i sprawdzenie typów, testy, npm run build, podgląd npm run preview, a na końcu vercel --prod.

GRATULACJE! Ukończyłeś szkolenie na Platformie Startowej NOVA LAB!

Twój kod przeszedł wszystkie testy przedstartowe i jest gotowy na misję marsjańską!

Teraz Twoja aplikacja:

  • Jest w pełni przetestowana (wszystkie systemy sprawdzone)
  • Zoptymalizowana pod kątem wydajności (gotowa na trudne warunki kosmiczne)
  • Gotowa do wdrożenia (procedura startowa zakończona)
  • Ma CI/CD pipeline (automatyczne systemy kontroli)
  • Działa w kontenerze Docker (hermetyczna kapsuła)

MISJA STARTOWA ZAKOŃCZONA SUKCESEM!

Moja rada: skopiuj ten zestaw plików do własnego repozytorium i dopasuj go do swojej aplikacji - to szkielet na każdy kolejny projekt Vue. Twój kod startuje na Marsa, a przed Tobą jeszcze trzy lokacje NOVA LAB; w Sali Holograficznej ożywisz interfejs animacjami.

Zapamiętaj: aplikacja jest gotowa do lotu dopiero wtedy, gdy testy, build i wdrożenie przechodzą automatycznie, bez udziału operatora.

Kod do tej lekcji: App.vue
<script setup>
import { ref, computed, onMounted } from 'vue'

// NOVA LAB - panel monitoringu
const metrics = ref({
  uptime: 99.9,
  responseTime: 145,
  errorRate: 0.02,
  activeUsers: 1247,
  requestsPerMinute: 3542,
  cpuUsage: 45,
  memoryUsage: 62,
  diskUsage: 38
})

const alerts = ref([
  { id: 1, level: 'warning', message: 'Wykryto wysokie zuzycie pamieci', time: '2 min temu' },
  { id: 2, level: 'info', message: 'Wdrozenie zakonczone pomyslnie', time: '15 min temu' }
])

const performanceData = ref([
  { time: '00:00', value: 120 },
  { time: '04:00', value: 95 },
  { time: '08:00', value: 180 },
  { time: '12:00', value: 220 },
  { time: '16:00', value: 195 },
  { time: '20:00', value: 150 }
])

const healthStatus = computed(() => {
  const { uptime, errorRate, responseTime } = metrics.value

  if (uptime >= 99.5 && errorRate < 0.1 && responseTime < 200) {
    return { status: 'healthy', label: 'Sprawny', color: '#00ff88' }
  } else if (uptime >= 99 && errorRate < 0.5 && responseTime < 500) {
    return { status: 'warning', label: 'Ostrzezenie', color: '#ffa500' }
  } else {
    return { status: 'critical', label: 'Krytyczny', color: '#ff0000' }
  }
})

const performanceScore = computed(() => {
  const avgResponseTime = metrics.value.responseTime
  if (avgResponseTime < 100) return 'Doskonala'
  if (avgResponseTime < 200) return 'Dobra'
  if (avgResponseTime < 500) return 'Przecietna'
  return 'Slaba'
})

function refreshMetrics() {
  // Symulacja aktualizacji metryk
  metrics.value.responseTime = Math.floor(Math.random() * 100) + 100
  metrics.value.activeUsers = Math.floor(Math.random() * 500) + 1000
  metrics.value.requestsPerMinute = Math.floor(Math.random() * 1000) + 3000
  metrics.value.cpuUsage = Math.floor(Math.random() * 30) + 30
  metrics.value.memoryUsage = Math.floor(Math.random() * 20) + 50
}

onMounted(() => {
  // Automatyczne odswiezanie co 5 sekund
  setInterval(refreshMetrics, 5000)
})
</script>

<template>
  <div class="monitoring-dashboard">
    <div class="header">
      <h1>Panel kontroli misji</h1>
      <p>Monitoring NOVA LAB w czasie rzeczywistym</p>
    </div>

    <div class="health-status" :style="{ borderColor: healthStatus.color }">
      <div class="status-icon" :style="{ color: healthStatus.color }">
        {{ healthStatus.status === 'healthy' ? 'OK' : healthStatus.status === 'warning' ? '!' : 'X' }}
      </div>
      <div class="status-info">
        <h2>Stan systemu: {{ healthStatus.label }}</h2>
        <p>Dostepnosc: {{ metrics.uptime }}% | Wydajnosc: {{ performanceScore }}</p>
      </div>
    </div>

    <div class="metrics-grid">
      <div class="metric-card">
        <div class="metric-icon">◆</div>
        <div class="metric-value">{{ metrics.activeUsers.toLocaleString() }}</div>
        <div class="metric-label">Aktywni uzytkownicy</div>
      </div>

      <div class="metric-card">
        <div class="metric-icon">↯</div>
        <div class="metric-value">{{ metrics.responseTime }}ms</div>
        <div class="metric-label">Sredni czas odpowiedzi</div>
      </div>

      <div class="metric-card">
        <div class="metric-icon">▲</div>
        <div class="metric-value">{{ metrics.requestsPerMinute.toLocaleString() }}</div>
        <div class="metric-label">Zapytania/min</div>
      </div>

      <div class="metric-card">
        <div class="metric-icon">●</div>
        <div class="metric-value">{{ metrics.errorRate }}%</div>
        <div class="metric-label">Odsetek bledow</div>
      </div>
    </div>

    <div class="resource-usage">
      <h3>Zuzycie zasobow</h3>
      <div class="resource-bars">
        <div class="resource-item">
          <div class="resource-header">
            <span>CPU</span>
            <span>{{ metrics.cpuUsage }}%</span>
          </div>
          <div class="resource-bar">
            <div
              class="resource-fill"
              :style="{
                width: metrics.cpuUsage + '%',
                background: metrics.cpuUsage > 80 ? '#ff0000' : metrics.cpuUsage > 60 ? '#ffa500' : '#00ff88'
              }"
            ></div>
          </div>
        </div>

        <div class="resource-item">
          <div class="resource-header">
            <span>Pamiec</span>
            <span>{{ metrics.memoryUsage }}%</span>
          </div>
          <div class="resource-bar">
            <div
              class="resource-fill"
              :style="{
                width: metrics.memoryUsage + '%',
                background: metrics.memoryUsage > 80 ? '#ff0000' : metrics.memoryUsage > 60 ? '#ffa500' : '#00ff88'
              }"
            ></div>
          </div>
        </div>

        <div class="resource-item">
          <div class="resource-header">
            <span>Dysk</span>
            <span>{{ metrics.diskUsage }}%</span>
          </div>
          <div class="resource-bar">
            <div
              class="resource-fill"
              :style="{
                width: metrics.diskUsage + '%',
                background: metrics.diskUsage > 80 ? '#ff0000' : metrics.diskUsage > 60 ? '#ffa500' : '#00ff88'
              }"
            ></div>
          </div>
        </div>
      </div>
    </div>

    <div class="alerts-panel">
      <h3>Ostatnie alerty</h3>
      <div class="alerts-list">
        <div
          v-for="alert in alerts"
          :key="alert.id"
          class="alert-item"
          :class="alert.level"
        >
          <span class="alert-icon">
            {{ alert.level === 'warning' ? '!' : alert.level === 'error' ? 'X' : 'ℹ' }}
          </span>
          <span class="alert-message">{{ alert.message }}</span>
          <span class="alert-time">{{ alert.time }}</span>
        </div>
      </div>
    </div>

    <div class="actions">
      <button @click="refreshMetrics" class="refresh-btn">
        Odswiez metryki
      </button>
    </div>
  </div>
</template>

<style scoped>
.monitoring-dashboard {
  background: #0a0e27;
  color: #00ff88;
  padding: 2rem;
  min-height: 100vh;
  font-family: 'Courier New', monospace;
}

.header {
  text-align: center;
  margin-bottom: 2rem;
  border-bottom: 2px solid #00b4d8;
  padding-bottom: 1rem;
}

.header h1 {
  color: #00ff88;
  text-shadow: 0 0 10px #00ff88;
  margin: 0;
}

.health-status {
  display: flex;
  align-items: center;
  gap: 1.5rem;
  background: rgba(0, 180, 216, 0.1);
  border: 3px solid;
  border-radius: 12px;
  padding: 1.5rem;
  margin-bottom: 2rem;
}

.status-icon {
  font-size: 3rem;
}

.status-info h2 {
  margin: 0 0 0.5rem 0;
  color: #fff;
}

.status-info p {
  margin: 0;
  color: #00b4d8;
}

.metrics-grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
  gap: 1.5rem;
  margin-bottom: 2rem;
}

.metric-card {
  background: rgba(0, 180, 216, 0.1);
  border: 2px solid #00b4d8;
  border-radius: 8px;
  padding: 1.5rem;
  text-align: center;
  transition: transform 0.3s;
}

.metric-card:hover {
  transform: translateY(-5px);
  box-shadow: 0 5px 20px rgba(0, 180, 216, 0.3);
}

.metric-icon {
  font-size: 2.5rem;
  margin-bottom: 0.5rem;
}

.metric-value {
  font-size: 2rem;
  color: #00ff88;
  font-weight: bold;
  margin-bottom: 0.5rem;
}

.metric-label {
  color: #00b4d8;
  font-size: 0.9rem;
}

.resource-usage, .alerts-panel {
  background: rgba(0, 180, 216, 0.1);
  border: 1px solid #00b4d8;
  border-radius: 8px;
  padding: 1.5rem;
  margin-bottom: 1.5rem;
}

.resource-usage h3, .alerts-panel h3 {
  color: #00b4d8;
  margin-top: 0;
}

.resource-bars {
  display: flex;
  flex-direction: column;
  gap: 1rem;
}

.resource-item {
  display: flex;
  flex-direction: column;
  gap: 0.5rem;
}

.resource-header {
  display: flex;
  justify-content: space-between;
  color: #fff;
  font-size: 0.9rem;
}

.resource-bar {
  height: 20px;
  background: rgba(0, 255, 136, 0.1);
  border-radius: 10px;
  overflow: hidden;
  border: 1px solid #00b4d8;
}

.resource-fill {
  height: 100%;
  transition: width 0.5s, background 0.5s;
  border-radius: 10px;
}

.alerts-list {
  display: flex;
  flex-direction: column;
  gap: 0.75rem;
}

.alert-item {
  display: flex;
  align-items: center;
  gap: 1rem;
  padding: 1rem;
  border-radius: 8px;
  border-left: 4px solid;
}

.alert-item.warning {
  background: rgba(255, 165, 0, 0.1);
  border-color: #ffa500;
}

.alert-item.error {
  background: rgba(255, 0, 0, 0.1);
  border-color: #ff0000;
}

.alert-item.info {
  background: rgba(0, 180, 216, 0.1);
  border-color: #00b4d8;
}

.alert-icon {
  font-size: 1.5rem;
}

.alert-message {
  flex: 1;
  color: #fff;
}

.alert-time {
  color: #00b4d8;
  font-size: 0.85rem;
}

.actions {
  text-align: center;
}

.refresh-btn {
  padding: 1rem 2rem;
  background: rgba(0, 180, 216, 0.2);
  border: 2px solid #00b4d8;
  color: #00b4d8;
  font-size: 1rem;
  font-family: 'Courier New', monospace;
  border-radius: 8px;
  cursor: pointer;
  transition: all 0.3s;
}

.refresh-btn:hover {
  background: #00b4d8;
  color: #0a0e27;
  box-shadow: 0 0 20px #00b4d8;
}
</style>

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. Jak zaimplementować lazy loading komponentu w Vue 3?

  2. 2. Jakie narzędzia pomagają monitorować performance aplikacji Vue?

To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż składnię lazy loading komponentu:

  • Edytor kodu

    Skonfiguruj pełną vite.config.js z: vue plugin, image optimizer, visualizer, build options z podziałem na pakiety (w Vite 8 przez codeSplitting zamiast manualChunks).

  • Układanie w pionie

    Uporządkuj kroki przygotowania do produkcji od pierwszego do ostatniego:

  • Klikanie w kolejności

    Ułóż komendę wdrożenia produkcyjnego na Vercel:

  • Układanie w pionie

    Uporządkuj kroki GitHub Actions CI/CD workflow:

  • Klikanie w kolejności

    Ułóż komendę wdrożenia produkcyjnego na Netlify:

  • Układanie w poziomie

    Ułóż dyrektywę nginx dla SPA routing:

  • Klikanie w kolejności

    Ułóż komendę uruchomienia kontenera Docker z mapowaniem portów:

  1. PytanieLazy loading komponentów
  2. Ułóż w kolejnościdefineAsyncComponent
  3. Zadanie z kodemPraktyka: Pełna konfiguracja produkcyjna
  4. PytaniePerformance monitoring
  5. Ułóż w kolejnościChecklist przed deployment
  6. Kliknij w kolejnościVercel CLI deployment
  7. PytanieSEO w Vue SPA
  8. PytanieTerser w Vite
  9. Ułóż w kolejnościGitHub Actions - etapy workflow
  10. Kliknij w kolejnościNetlify deploy CLI
  11. Ułóż w kolejnościNginx try_files
  12. Kliknij w kolejnościDocker run
  13. Projekt do wysłaniaWysłanie finalnego projektu do Mentora
  14. WideoPodsumowanie modułu

Przydatne artykuły