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

Deployment

6 min czytania ·
W tej lekcji7

Wdrożenie aplikacji na serwer - start rakiety! Twój kod leci do produkcji jak rakieta na Marsa!

Folder dist z poprzedniej lekcji leży na Twoim dysku. Trzeba go wynieść na orbitę: na serwer, który pod stałym adresem i przez HTTPS poda pliki każdemu technikowi - i to bez ręcznego kopiowania przy każdej poprawce. Odpowiedzią jest CI/CD, czyli Continuous Integration i Continuous Deployment - automatyzacja testów, buildu i wdrożeń, która po każdym wypchnięciu kodu sama przechodzi procedurę startową.

Deployment na Vercel

Najprościej podłączyć repozytorium Git w panelu Vercela. Vercel sam wykryje projekt Vite i ustawi komendę npm run build oraz katalog dist, a potem wdroży produkcję po każdym pushu do głównej gałęzi i przygotuje adres podglądu dla każdego pull requesta. Gdy wolisz terminal, użyj Vercel CLI:

# Install Vercel CLI
npm install -g vercel

# Deploy
vercel

# Production deployment
vercel --prod

Samo vercel to skrót od vercel deploy, bo deploy jest domyślnym poleceniem CLI. Bez flagi powstaje wdrożenie podglądowe pod unikalnym adresem, a --prod publikuje je pod domeną produkcyjną; tylko pierwsze wdrożenie nowego projektu zawsze trafia na produkcję. Ustawienia możesz trzymać w repozytorium, w pliku vercel.json:

// vercel.json
{
  "buildCommand": "npm run build",
  "outputDirectory": "dist",
  "framework": "vite",
  "rewrites": [
    { "source": "/(.*)", "destination": "/index.html" }
  ]
}

Pola buildCommand, outputDirectory i framework powtarzają to, co Vercel wykrywa sam, ale nie zależą od kliknięć w panelu. Najważniejsza jest sekcja rewrites.

Dlaczego SPA potrzebuje przepisywania adresów

Aplikacja z Vue Router to SPA: serwer ma tylko index.html, a trasy w rodzaju /gallery obsługuje JavaScript w przeglądarce. Gdy technik odświeży stronę na /gallery, przeglądarka poprosi serwer o nieistniejący plik /gallery i dostanie 404. Reguła przepisywania każe dla każdej ścieżki oddać index.html, a router wyświetli właściwy widok.

Deployment na Netlify

Netlify działa podobnie: podłączasz repozytorium albo korzystasz z CLI. Polecenie netlify deploy publikuje wersję roboczą pod adresem podglądu, a z flagą --prod wersję produkcyjną:

# Install Netlify CLI
npm install -g netlify-cli

# Deploy
netlify deploy

# Production
netlify deploy --prod

Konfiguracja trafia do netlify.toml. Sekcja [build] podaje komendę budowania i katalog do publikacji, a [[redirects]] robi dla SPA to samo, co rewrites na Vercelu:

# netlify.toml
[build]
  command = "npm run build"
  publish = "dist"

[[redirects]]
  from = "/*"
  to = "/index.html"
  status = 200

Status 200 oznacza przepisanie, więc adres zostaje bez zmian. Z kodem 301 przeglądarka przeskoczyłaby na stronę główną i technik zgubiłby trasę.

Deployment na GitHub Pages

GitHub Pages hostuje stronę prosto z repozytorium. Paczka gh-pages wysyła zawartość dist na osobną gałąź:

npm install -D gh-pages

Strona projektu działa pod adresem z nazwą repozytorium, na przykład https://user.github.io/repository-name/. Dlatego w vite.config.js ustawiasz base, czyli ścieżkę, od której Vite zbuduje odwołania do plików:

// vite.config.js
export default defineConfig({
  base: '/repository-name/', // Nazwa repo
  plugins: [vue()]
})

Bez base przeglądarka szukałaby skryptów w katalogu głównym domeny i pokazałaby pustą stronę; dla strony użytkownika zostaw base: '/'. Pozostaje skrypt wdrożenia:

// package.json
{
  "scripts": {
    "deploy": "npm run build && gh-pages -d dist"
  }
}

npm run deploy buduje aplikację i publikuje dist. GitHub Pages nie obsługuje reguł przepisywania, więc odświeżenie głębokiej trasy SPA da 404. Dokumentacja Vite opisuje też wdrażanie przez GitHub Actions zamiast paczki gh-pages.

Docker Deployment

Własny serwer wymaga obrazu Docker. Dockerfile używa budowania wieloetapowego (multi-stage build): pierwszy etap na obrazie Node buduje aplikację, drugi na lekkim nginx tylko ją serwuje:

# Dockerfile
FROM node:24-alpine AS builder

WORKDIR /app

COPY package*.json ./
RUN npm ci

COPY . .
RUN npm run build

FROM nginx:alpine

COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf

EXPOSE 80

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

COPY --from=builder przenosi z pierwszego etapu wyłącznie dist, więc kod źródłowy, node_modules i sam Node nie trafiają do końcowego obrazu. Obraz bazowy to Node 24, aktualna wersja LTS - Vite 8 wymaga co najmniej Node 20.19 lub 22.12, więc dawny node:18 przerwałby build. nginx potrzebuje jeszcze reguły dla SPA:

# nginx.conf
server {
  listen 80;
  server_name localhost;

  root /usr/share/nginx/html;
  index index.html;

  location / {
    try_files $uri $uri/ /index.html;
  }

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

try_files $uri $uri/ /index.html sprawdza po kolei plik, katalog, a w ostateczności oddaje index.html. Roczne cache dla zasobów jest bezpieczne, bo zmiana kodu zmienia hash w nazwie pliku. Zostaje zbudować obraz i uruchomić kontener:

# Build and run
docker build -t gallery-app .
docker run -p 8080:80 gallery-app

-t gallery-app nadaje obrazowi nazwę, a kropka wskazuje bieżący katalog jako kontekst budowania. -p 8080:80 łączy port 8080 komputera z portem 80 kontenera, więc aplikacja działa pod http://localhost:8080.

CI/CD with GitHub Actions

Workflow GitHub Actions to plik YAML w katalogu .github/workflows, uruchamiany przy zdarzeniach z sekcji on. Ten przechodzi procedurę startową po każdym pushu do main:

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

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v7

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

      - name: Install dependencies
        run: npm ci

      - name: Run tests
        run: npm test

      - name: Build
        run: npm run build

      - 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'

Kroki idą po kolei: actions/checkout pobiera kod, actions/setup-node instaluje Node, npm ci instaluje zależności dokładnie według package-lock.json, potem testy, build i wdrożenie. Gdy któryś krok zawiedzie, następne się nie wykonają. W pełnym pipeline przed testami stoi jeszcze linting (npm run lint) - zobaczysz go w projekcie. secrets to tajne klucze z ustawień repozytorium, a amondnet/vercel-action to akcja społeczności - projekt podłączony do Vercela przez Git tego kroku nie potrzebuje.

Performance Checklist

  • Lazy load routes - widoki ładowane dopiero przy wejściu na trasę
  • Code splitting - biblioteki w osobnych pakietach trzymanych w cache
  • Image optimization - obrazy ważą zwykle więcej niż kod
  • Minification - Vite robi ją domyślnie
  • Gzip/Brotli compression - kompresja po stronie serwera
  • CDN dla statycznych zasobów - pliki bliżej użytkownika
  • Cache headers - długie dla plików z hashem, krótkie dla index.html
  • Preload critical resources - Vite sam dodaje modulepreload
  • Remove console.logs - minifikator wytnie je po włączeniu odpowiedniej opcji
  • Source maps tylko dla dev - publicznie tylko świadomie, np. sourcemap: 'hidden' dla raportowania błędów

Moja rada: na start wybierz Vercel albo Netlify z integracją Git - HTTPS, CDN i podglądy pull requestów dostajesz bez konfiguracji. Dockera zostaw na czas, gdy aplikacja musi stanąć na infrastrukturze stacji. W projekcie końcowym spinasz testy, build i wdrożenie w jeden pipeline.

Zapamiętaj: CI/CD to automatyczna procedura przedstartowa, która nie pozwoli wystartować z uszkodzonym systemem.

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

// NOVA LAB - wizualizacja pipeline CI/CD
const pipelineStages = ref([
  { id: 1, name: 'Kod zrodlowy', status: 'completed', duration: 2, icon: '' },
  { id: 2, name: 'Build', status: 'idle', duration: 45, icon: '' },
  { id: 3, name: 'Testy', status: 'idle', duration: 30, icon: '' },
  { id: 4, name: 'Skan bezpieczenstwa', status: 'idle', duration: 20, icon: '' },
  { id: 5, name: 'Wdrozenie staging', status: 'idle', duration: 25, icon: '' },
  { id: 6, name: 'Wdrozenie produkcyjne', status: 'idle', duration: 30, icon: '' }
])

const pipelineRunning = ref(false)
const currentStage = ref(0)
const pipelineProgress = ref(0)

const logs = ref([
  '→ Pipeline gotowy do startu...'
])

let stageInterval = null

const overallProgress = computed(() => {
  const completed = pipelineStages.value.filter(s => s.status === 'completed').length
  return Math.round((completed / pipelineStages.value.length) * 100)
})

const pipelineStatus = computed(() => {
  if (pipelineStages.value.some(s => s.status === 'failed')) return 'failed'
  if (pipelineStages.value.every(s => s.status === 'completed')) return 'success'
  if (pipelineRunning.value) return 'running'
  return 'idle'
})

function startPipeline() {
  pipelineRunning.value = true
  currentStage.value = 0
  pipelineProgress.value = 0
  logs.value = ['Start pipeline CI/CD...']

  // Reset wszystkich etapow poza pierwszym
  pipelineStages.value.forEach((stage, index) => {
    stage.status = index === 0 ? 'completed' : 'idle'
  })

  runNextStage()
}

function runNextStage() {
  if (currentStage.value >= pipelineStages.value.length - 1) {
    completePipeline()
    return
  }

  currentStage.value++
  const stage = pipelineStages.value[currentStage.value]
  stage.status = 'running'

  logs.value.push(`→ W toku: ${stage.name}...`)

  pipelineProgress.value = 0
  const increment = 100 / (stage.duration / 10)

  stageInterval = setInterval(() => {
    pipelineProgress.value += increment

    if (pipelineProgress.value >= 100) {
      clearInterval(stageInterval)
      stage.status = 'completed'
      logs.value.push(`${stage.name}: zakonczono pomyslnie`)

      setTimeout(() => {
        runNextStage()
      }, 500)
    }
  }, 100)
}

function completePipeline() {
  pipelineRunning.value = false
  logs.value.push('Pipeline zakonczony pomyslnie!')
  logs.value.push('Misja marsjanska wdrozona na produkcje!')
}

function resetPipeline() {
  if (stageInterval) clearInterval(stageInterval)
  pipelineRunning.value = false
  currentStage.value = 0
  pipelineProgress.value = 0

  pipelineStages.value.forEach((stage, index) => {
    stage.status = index === 0 ? 'completed' : 'idle'
  })

  logs.value = ['→ Pipeline zresetowany. Gotowy do startu...']
}
</script>

<template>
  <div class="cicd-dashboard">
    <div class="header">
      <h1>Monitor pipeline CI/CD</h1>
      <p>Automatyczny system wdrozen NOVA LAB</p>
    </div>

    <div class="pipeline-status" :class="pipelineStatus">
      <div class="status-indicator">
        <template v-if="pipelineStatus === 'idle'">Bezczynny</template>
        <template v-else-if="pipelineStatus === 'running'">W toku</template>
        <template v-else-if="pipelineStatus === 'success'">Sukces</template>
        <template v-else-if="pipelineStatus === 'failed'">Blad</template>
      </div>
      <div class="overall-progress">
        Postep: {{ overallProgress }}%
      </div>
    </div>

    <div class="pipeline-visualization">
      <div
        v-for="stage in pipelineStages"
        :key="stage.id"
        class="pipeline-stage"
        :class="stage.status"
      >
        <div class="stage-icon">{{ stage.icon }}</div>
        <div class="stage-name">{{ stage.name }}</div>
        <div class="stage-status">
          <template v-if="stage.status === 'idle'"></template>
          <template v-else-if="stage.status === 'running'"></template>
          <template v-else-if="stage.status === 'completed'"></template>
          <template v-else-if="stage.status === 'failed'"></template>
        </div>
        <div v-if="stage.status === 'running'" class="stage-progress">
          <div class="progress-bar">
            <div class="progress-fill" :style="{ width: pipelineProgress + '%' }"></div>
          </div>
        </div>
      </div>
    </div>

    <div class="logs-panel">
      <h3>Logi pipeline</h3>
      <div class="logs">
        <div v-for="(log, index) in logs" :key="index" class="log-entry">
          {{ log }}
        </div>
      </div>
    </div>

    <div class="controls">
      <button
        @click="startPipeline"
        :disabled="pipelineRunning"
        class="start-btn"
      >
        ▸ Uruchom pipeline
      </button>
      <button
        @click="resetPipeline"
        class="reset-btn"
      >
        Reset
      </button>
    </div>
  </div>
</template>

<style scoped>
.cicd-dashboard {
  background: linear-gradient(135deg, #0a0e27 0%, #1a1e3f 100%);
  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;
}

.pipeline-status {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 1.5rem;
  border-radius: 8px;
  margin-bottom: 2rem;
  border: 2px solid;
}

.pipeline-status.idle {
  background: rgba(128, 128, 128, 0.1);
  border-color: #888;
}

.pipeline-status.running {
  background: rgba(0, 180, 216, 0.2);
  border-color: #00b4d8;
  animation: pulse 2s infinite;
}

.pipeline-status.success {
  background: rgba(0, 255, 136, 0.2);
  border-color: #00ff88;
}

.pipeline-status.failed {
  background: rgba(255, 0, 0, 0.2);
  border-color: #ff0000;
}

.status-indicator {
  font-size: 1.3rem;
  font-weight: bold;
}

.pipeline-visualization {
  display: flex;
  flex-direction: column;
  gap: 1rem;
  margin-bottom: 2rem;
}

.pipeline-stage {
  background: rgba(0, 180, 216, 0.1);
  border: 2px solid #00b4d8;
  border-radius: 8px;
  padding: 1rem;
  display: grid;
  grid-template-columns: 50px 1fr 50px;
  align-items: center;
  gap: 1rem;
  transition: all 0.3s;
}

.pipeline-stage.running {
  border-color: #00b4d8;
  background: rgba(0, 180, 216, 0.2);
  box-shadow: 0 0 20px rgba(0, 180, 216, 0.3);
}

.pipeline-stage.completed {
  border-color: #00ff88;
  background: rgba(0, 255, 136, 0.1);
}

.stage-icon {
  font-size: 2rem;
  text-align: center;
}

.stage-name {
  color: #fff;
  font-size: 1.1rem;
}

.stage-status {
  font-size: 1.5rem;
  text-align: center;
}

.stage-progress {
  grid-column: 1 / -1;
  margin-top: 0.5rem;
}

.progress-bar {
  height: 8px;
  background: rgba(0, 255, 136, 0.1);
  border-radius: 4px;
  overflow: hidden;
}

.progress-fill {
  height: 100%;
  background: linear-gradient(90deg, #00b4d8, #00ff88);
  transition: width 0.3s;
}

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

.logs-panel h3 {
  color: #00b4d8;
  margin-top: 0;
}

.logs {
  background: #000;
  border-radius: 4px;
  padding: 1rem;
  max-height: 200px;
  overflow-y: auto;
  font-family: monospace;
}

.log-entry {
  color: #00ff88;
  margin-bottom: 0.5rem;
  font-size: 0.9rem;
}

.controls {
  display: flex;
  gap: 1rem;
  justify-content: center;
}

.start-btn, .reset-btn {
  padding: 1rem 2rem;
  font-size: 1rem;
  font-family: 'Courier New', monospace;
  border-radius: 8px;
  cursor: pointer;
  border: 2px solid;
  transition: all 0.3s;
}

.start-btn {
  background: #00ff88;
  color: #0a0e27;
  border-color: #00ff88;
}

.start-btn:disabled {
  opacity: 0.5;
  cursor: not-allowed;
}

.start-btn:hover:not(:disabled) {
  box-shadow: 0 0 20px #00ff88;
}

.reset-btn {
  background: rgba(0, 180, 216, 0.2);
  color: #00b4d8;
  border-color: #00b4d8;
}

.reset-btn:hover {
  background: #00b4d8;
  color: #0a0e27;
}
</style>

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 wdrożyć aplikację Vue na platformę Vercel?

  2. 2. Jakie ustawienia build są potrzebne przy deployment na Netlify?

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

Zadania praktyczne w grze

  • Edytor kodu

    Uzupełnij plik vercel.json z konfiguracją buildCommand, outputDirectory, framework i rewrites dla SPA.

  • Układanie w pionie

    Uporządkuj etapy pipeline CI/CD od pierwszego do ostatniego:

  • Układanie w pionie

    Ułóż etapy pipeline CI/CD od kodu do produkcji:

  • Klikanie w kolejności

    Ułóż komendę budowania obrazu Docker:

  • Układanie w poziomie

    Ułóż konfigurację Vite dla GitHub Pages:

  • Edytor kodu

    Uzupełnij Dockerfile z multi-stage build: etap budowania (node) i etap produkcyjny (nginx).

  1. PytanieDeployment na Vercel
  2. PytanieNetlify - konfiguracja build
  3. Zadanie z kodemPraktyka: Konfiguracja Vercel
  4. Ułóż w kolejnościProces CI/CD
  5. Ułóż w kolejnościPipeline CI/CD dla Vue
  6. Kliknij w kolejnościDocker build - komendy
  7. PytanieSPA routing na serwerze
  8. Ułóż w kolejnościGitHub Pages - base path
  9. Zadanie z kodemPraktyka: Dockerfile
  10. PytanieCI/CD - GitHub Actions

Przydatne artykuły