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

CI/CD i automatyzacja wdrożeń

13 min czytania ·
W tej lekcji12

W nowoczesnym procesie rozwoju oprogramowania, Continuous Integration (CI) i Continuous Deployment (CD) są kluczowymi praktykami, które pozwalają na szybsze i bardziej niezawodne dostarczanie aplikacji. Next.js, jako nowoczesny framework, doskonale integruje się z różnymi narzędziami CI/CD, co pozwala zautomatyzować proces testowania, budowania i wdrażania aplikacji.

Czym są CI/CD?

Continuous Integration (CI)

Continuous Integration to praktyka, w której programiści regularnie integrują swoje zmiany w kodzie z główną gałęzią repozytorium. Każda integracja jest automatycznie weryfikowana przez:

  • Uruchomienie testów jednostkowych i integracyjnych
  • Analizę statyczną kodu (linting)
  • Sprawdzanie jakości kodu
  • Sprawdzanie typów (w przypadku TypeScript)

CI pozwala na wczesne wykrywanie błędów i zapewnia, że kod w głównej gałęzi pozostaje stabilny.

Continuous Deployment (CD)

Continuous Deployment idzie o krok dalej - po pomyślnym przejściu etapu CI, automatycznie wdraża zmiany na środowisko produkcyjne lub testowe. Proces CD obejmuje:

  • Automatyczne budowanie aplikacji
  • Wdrażanie na wybrane środowisko (staging, produkcja)
  • Automatyczne testy E2E po wdrożeniu
  • Monitorowanie wdrożenia

Popularne narzędzia CI/CD dla aplikacji Next.js

Dla aplikacji Next.js możemy wykorzystać różne narzędzia CI/CD:

  1. GitHub Actions - zintegrowane z GitHub, oferuje doskonałą integrację z repo
  2. GitLab CI/CD - wbudowane w GitLab, pozwala na tworzenie potoków CI/CD
  3. CircleCI - popularna platforma CI/CD z prostym konfigurowaniem
  4. Jenkins - otwarty, rozszerzalny serwer automatyzacji
  5. Vercel CI/CD - natywne rozwiązanie dla aplikacji Next.js
  6. Netlify CI/CD - alternatywa z podobnymi funkcjami
  7. Travis CI - jedna z najstarszych platform CI/CD

Konfiguracja CI/CD z GitHub Actions

Najprostszym sposobem na wdrożenie CI/CD dla projektu Next.js jest użycie GitHub Actions, jeśli twoje repozytorium jest hostowane na GitHub.

1. Konfiguracja workflow testowania

Utwórz plik .github/workflows/ci.yml w swoim repozytorium:

name: CI

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

jobs:
  test:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18.x]

    steps:
      - uses: actions/checkout@v3

      - name: Use Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}
          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 test

      - name: Build
        run: npm run build

Ten workflow uruchamia się przy każdym pushu do gałęzi main i development oraz przy utworzeniu Pull Requestu do tych gałęzi.

2. Konfiguracja workflow wdrażania na Vercel

Utwórz plik .github/workflows/deploy.yml:

name: Deploy to Production

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

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

Aby to działało, musisz skonfigurować następujące sekrety w ustawieniach repozytorium:

  • VERCEL_TOKEN - Token API Vercel
  • ORG_ID - ID organizacji w Vercel
  • PROJECT_ID - ID projektu w Vercel

3. Konfiguracja workflow dla środowiska staging

name: Deploy to Staging

on:
  push:
    branches: [development]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Deploy to Vercel (Preview)
        uses: amondnet/vercel-action@v20
        with:
          vercel-token: ${{ secrets.VERCEL_TOKEN }}
          vercel-org-id: ${{ secrets.ORG_ID }}
          vercel-project-id: ${{ secrets.PROJECT_ID }}
          github-comment: true

Konfiguracja CI/CD z GitLab CI

Jeśli korzystasz z GitLab, możesz skonfigurować CI/CD używając .gitlab-ci.yml:

image: node:18-alpine

stages:
  - test
  - build
  - deploy_staging
  - deploy_production

cache:
  key: ${CI_COMMIT_REF_SLUG}
  paths:
    - node_modules/
    - .next/cache/

test:
  stage: test
  script:
    - npm ci
    - npm run lint
    - npm run type-check
    - npm test
  except:
    - tags

build:
  stage: build
  script:
    - npm ci
    - npm run build
  artifacts:
    paths:
      - .next/
  except:
    - tags

deploy_staging:
  stage: deploy_staging
  script:
    - npm install -g vercel
    - vercel --token ${VERCEL_TOKEN} --confirm
  environment:
    name: staging
    url: ${CI_PROJECT_NAME}-git-${CI_COMMIT_REF_NAME}-${CI_PROJECT_NAMESPACE}.vercel.app
  only:
    - development

deploy_production:
  stage: deploy_production
  script:
    - npm install -g vercel
    - vercel --token ${VERCEL_TOKEN} --prod --confirm
  environment:
    name: production
    url: ${CI_PROJECT_NAME}.vercel.app
  only:
    - main

Konfiguracja CI/CD dla aplikacji Next.js z Circle CI

Aby skonfigurować CircleCI, utwórz plik .circleci/config.yml:

version: 2.1

orbs:
  node: circleci/node@5.0.3

jobs:
  test:
    docker:
      - image: cimg/node:18.15.0
    steps:
      - checkout
      - node/install-packages:
          pkg-manager: npm
      - run:
          name: Run tests
          command: npm test
      - run:
          name: Run linter
          command: npm run lint
      - run:
          name: Check types
          command: npm run type-check

  build:
    docker:
      - image: cimg/node:18.15.0
    steps:
      - checkout
      - node/install-packages:
          pkg-manager: npm
      - run:
          name: Build application
          command: npm run build
      - persist_to_workspace:
          root: .
          paths:
            - .next
            - node_modules
            - package.json

  deploy-staging:
    docker:
      - image: cimg/node:18.15.0
    steps:
      - checkout
      - attach_workspace:
          at: .
      - run:
          name: Install Vercel CLI
          command: npm install -g vercel
      - run:
          name: Deploy to Staging
          command: vercel --token ${VERCEL_TOKEN} --confirm

  deploy-production:
    docker:
      - image: cimg/node:18.15.0
    steps:
      - checkout
      - attach_workspace:
          at: .
      - run:
          name: Install Vercel CLI
          command: npm install -g vercel
      - run:
          name: Deploy to Production
          command: vercel --token ${VERCEL_TOKEN} --prod --confirm

workflows:
  version: 2
  test-build-deploy:
    jobs:
      - test
      - build:
          requires:
            - test
      - deploy-staging:
          requires:
            - build
          filters:
            branches:
              only: development
      - deploy-production:
          requires:
            - build
          filters:
            branches:
              only: main

Konfiguracja CI/CD z Jenkins

Jenkins jest potężnym narzędziem CI/CD, ale wymaga większej konfiguracji. Oto przykładowy Jenkinsfile dla potoku CI/CD dla aplikacji Next.js:

pipeline {
    agent {
        docker {
            image 'node:18-alpine'
        }
    }

    stages {
        stage('Install Dependencies') {
            steps {
                sh 'npm ci'
            }
        }

        stage('Lint') {
            steps {
                sh 'npm run lint'
            }
        }

        stage('Type Check') {
            steps {
                sh 'npm run type-check'
            }
        }

        stage('Test') {
            steps {
                sh 'npm test'
            }
        }

        stage('Build') {
            steps {
                sh 'npm run build'
            }
        }

        stage('Deploy to Staging') {
            when {
                branch 'development'
            }
            steps {
                sh 'npm install -g vercel'
                sh 'vercel --token ${VERCEL_TOKEN} --confirm'
            }
        }

        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            steps {
                sh 'npm install -g vercel'
                sh 'vercel --token ${VERCEL_TOKEN} --prod --confirm'
            }
        }
    }

    post {
        always {
            cleanWs()
        }
    }
}

Testowanie w procesie CI/CD

Ważnym elementem procesu CI/CD jest automatyczne testowanie. Dla aplikacji Next.js możemy skonfigurować różne rodzaje testów:

1. Testy jednostkowe z Jest i React Testing Library

// __tests__/components/Header.test.tsx
import { render, screen } from '@testing-library/react';
import Header from '@/components/Header';

describe('Header Component', () => {
  it('renders the logo', () => {
    render(<Header />);
    const logo = screen.getByAltText('Logo');
    expect(logo).toBeInTheDocument();
  });

  it('has the correct navigation links', () => {
    render(<Header />);
    expect(screen.getByText('Home')).toBeInTheDocument();
    expect(screen.getByText('About')).toBeInTheDocument();
    expect(screen.getByText('Contact')).toBeInTheDocument();
  });
});

2. Testy integracyjne dla API Routes

// __tests__/api/user.test.ts
import { createMocks } from 'node-mocks-http';
import userHandler from '@/app/api/user/route';

describe('/api/user endpoint', () => {
  it('returns a user when provided with a valid ID', async () => {
    const { req, res } = createMocks({
      method: 'GET',
      query: { id: '123' },
    });

    await userHandler(req, res);

    expect(res._getStatusCode()).toBe(200);
    expect(JSON.parse(res._getData())).toEqual(
      expect.objectContaining({
        id: '123',
        name: expect.any(String),
      })
    );
  });

  it('returns 404 for non-existent user', async () => {
    const { req, res } = createMocks({
      method: 'GET',
      query: { id: 'non-existent' },
    });

    await userHandler(req, res);

    expect(res._getStatusCode()).toBe(404);
  });
});

3. Testy End-to-End z Cypress

// cypress/integration/navigation.spec.js
describe('Navigation', () => {
  it('should navigate to the about page', () => {
    cy.visit('/');

    cy.get('a[href*="about"]').click();

    cy.url().should('include', '/about');
    cy.get('h1').contains('About');
  });

  it('should navigate to the contact page', () => {
    cy.visit('/');

    cy.get('a[href*="contact"]').click();

    cy.url().should('include', '/contact');
    cy.get('h1').contains('Contact');
  });
});

Dodaj konfigurację Cypress do GitHub Actions:

# .github/workflows/e2e-tests.yml
name: E2E Tests

on:
  deployment_status:

jobs:
  e2e-tests:
    if: github.event.deployment_status.state == 'success'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Install dependencies
        run: npm ci

      - name: Cypress run
        uses: cypress-io/github-action@v5
        with:
          record: true
        env:
          CYPRESS_RECORD_KEY: ${{ secrets.CYPRESS_RECORD_KEY }}
          CYPRESS_BASE_URL: ${{ github.event.deployment_status.target_url }}

Automatyzacja tasków deweloperskich

Poza CI/CD, możemy zautomatyzować różne inne zadania deweloperskie:

1. Automatyczne formatowanie kodu z Husky i lint-staged

Zainstaluj potrzebne pakiety:

npm install --save-dev husky lint-staged prettier

Zaktualizuj package.json:

{
  "scripts": {
    "prepare": "husky install"
  },
  "lint-staged": {
    "*.{js,jsx,ts,tsx}": [
      "prettier --write",
      "eslint --fix"
    ],
    "*.{json,md}": [
      "prettier --write"
    ]
  }
}

Utwórz hook pre-commit:

npx husky add .husky/pre-commit "npx lint-staged"

2. Automatyczne wersjonowanie z Semantic Release

Zainstaluj potrzebne pakiety:

npm install --save-dev semantic-release @semantic-release/git @semantic-release/changelog

Utwórz plik .releaserc.json:

{
  "branches": ["main"],
  "plugins": [
    "@semantic-release/commit-analyzer",
    "@semantic-release/release-notes-generator",
    "@semantic-release/changelog",
    "@semantic-release/npm",
    ["@semantic-release/git", {
      "assets": ["package.json", "CHANGELOG.md"],
      "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
    }],
    "@semantic-release/github"
  ]
}

Dodaj workflow dla semantic-release:

# .github/workflows/release.yml
name: Release

on:
  push:
    branches: [main]

jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'
      - name: Install dependencies
        run: npm ci
      - name: Release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
        run: npx semantic-release

3. Automatyczne generowanie dokumentacji

W przypadku projektów z TypeScript, możesz zautomatyzować generowanie dokumentacji:

# .github/workflows/docs.yml
name: Generate Documentation

on:
  push:
    branches: [main]

jobs:
  docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'
      - name: Install dependencies
        run: npm ci
      - name: Generate docs
        run: npx typedoc --out docs src
      - name: Deploy docs to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./docs

Strategie wdrażania i rollbacków

Podczas wdrażania aplikacji warto zaimplementować bezpieczne strategie wdrażania:

1. Blue-Green Deployment

Blue-Green deployment polega na utrzymywaniu dwóch identycznych środowisk produkcyjnych, z których tylko jedno jest aktywne. W przypadku Vercel, możesz skorzystać z ich wbudowanej funkcji "Preview Deployments" i aliasowania domen:

// scripts/blue-green-deploy.js
const { execSync } = require('child_process');

// Deploy to new environment (but not live yet)
const output = execSync('vercel --prod').toString();
const deploymentUrl = output.match(/https:\/\/[\w.-]+/)[0];

// Run smoke tests against new deployment
const smokeTestResult = execSync(`npm run test:smoke -- --url=${deploymentUrl}`).toString();

if (smokeTestResult.includes('All tests passed')) {
  // Switch traffic to new deployment
  execSync(`vercel alias set ${deploymentUrl} your-production-domain.com`);
  console.log('Successfully switched to new deployment');
} else {
  console.error('Smoke tests failed, aborting deployment');
  process.exit(1);
}

2. Canary Releases

W strategii Canary, nowa wersja jest udostępniana stopniowo, początkowo tylko dla małego procentu użytkowników. W Next.js możesz to osiągnąć za pomocą flag funkcji i podziału ruchu:

// lib/feature-flags.ts
import { useEffect, useState } from 'react';

const CANARY_PERCENTAGE = 10; // 10% użytkowników dostanie nową wersję

export function useCanaryFeature(featureName: string): boolean {
  const [isEnabled, setIsEnabled] = useState(false);

  useEffect(() => {
    // Generuj losową liczbę dla użytkownika i zapisz w local storage
    let userBucket = localStorage.getItem('userBucket');
    if (!userBucket) {
      userBucket = Math.floor(Math.random() * 100).toString();
      localStorage.setItem('userBucket', userBucket);
    }

    // Sprawdź, czy użytkownik jest w grupie canary
    const inCanaryGroup = parseInt(userBucket) < CANARY_PERCENTAGE;

    // Sprawdź, czy funkcja jest aktywna dla tego użytkownika
    fetch('/api/feature-flags')
      .then(res => res.json())
      .then(flags => {
        // Jeśli flaga istnieje i użytkownik jest w grupie canary, włącz funkcję
        if (flags[featureName] && inCanaryGroup) {
          setIsEnabled(true);
        }
      });
  }, [featureName]);

  return isEnabled;
}

3. Automatyczny rollback

Wdrożenie automatycznego rollbacku w przypadku problemów jest kluczową praktyką:

# .github/workflows/deploy-monitor-rollback.yml
name: Deploy, Monitor & Rollback

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    outputs:
      deployment_id: ${{ steps.deploy.outputs.deployment_id }}
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to Vercel
        id: deploy
        uses: amondnet/vercel-action@v20
        with:
          vercel-token: ${{ secrets.VERCEL_TOKEN }}
          vercel-org-id: ${{ secrets.ORG_ID }}
          vercel-project-id: ${{ secrets.PROJECT_ID }}
          vercel-args: '--prod'


  monitor:
    needs: deploy
    runs-on: ubuntu-latest
    steps:
      - name: Wait for 2 minutes
        run: sleep 120

      - name: Check for errors
        id: check_errors
        run: |
          ERROR_COUNT=$(curl -s "https://api.example.com/monitoring/errors?since=$(date -u -d '2 minutes ago' +%Y-%m-%dT%H:%M:%SZ)" | jq '.count')
          echo "::set-output name=error_count::$ERROR_COUNT"
          if [ "$ERROR_COUNT" -gt "10" ]; then
            echo "Error count too high ($ERROR_COUNT). Failing job."
            exit 1
          fi

      - name: Monitor Core Web Vitals
        id: web_vitals
        run: |
          LCP=$(curl -s "https://api.example.com/monitoring/web-vitals" | jq '.lcp')
          if [ "$LCP" -gt "2500" ]; then
            echo "LCP too high ($LCP ms). Failing job."
            exit 1
          fi

  rollback:
    needs: [deploy, monitor]
    runs-on: ubuntu-latest
    if: ${{ failure() }}
    steps:
      - name: Rollback to previous deployment
        uses: amondnet/vercel-action@v20
        with:
          vercel-token: ${{ secrets.VERCEL_TOKEN }}
          vercel-org-id: ${{ secrets.ORG_ID }}
          vercel-project-id: ${{ secrets.PROJECT_ID }}
          vercel-args: '--prod --scope myorg'  # Rollback to previous deployment

Zarządzanie zmiennymi środowiskowymi

Bezpieczne zarządzanie zmiennymi środowiskowymi jest krytycznym aspektem CI/CD:

1. Przechowywanie zmiennych środowiskowych w systemie CI/CD

Większość systemów CI/CD oferuje bezpieczne przechowywanie sekretów, np. GitHub Secrets:

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

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Create .env file
        run: |
          cat > .env.production << EOL
          DATABASE_URL=${{ secrets.DATABASE_URL }}
          API_KEY=${{ secrets.API_KEY }}
          NEXT_PUBLIC_ANALYTICS_ID=${{ secrets.NEXT_PUBLIC_ANALYTICS_ID }}
          EOL

      - name: Deploy
        run: npm run deploy

2. Automatyczna rotacja sekretów

W przypadku krytycznych aplikacji warto zaimplementować automatyczną rotację sekretów:

# .github/workflows/rotate-secrets.yml
name: Rotate Secrets

on:
  schedule:
    - cron: '0 0 1 * *'  # Co miesiąc

jobs:
  rotate:
    runs-on: ubuntu-latest
    steps:
      - name: Generate new API key
        id: new_key
        run: echo "::set-output name=api_key::$(openssl rand -base64 32)"

      - name: Update API service with new key
        run: |
          curl -X POST -H "Authorization: Bearer ${{ secrets.ADMIN_TOKEN }}"           -d '{"api_key": "${{ steps.new_key.outputs.api_key }}"}'           https://api.example.com/admin/update-key

      - name: Update GitHub secret
        uses: gliech/create-github-secret-action@v1
        with:
          name: API_KEY
          value: ${{ steps.new_key.outputs.api_key }}
          pa_token: ${{ secrets.PA_TOKEN }}

Monitorowanie wdrożeń

Kluczowym elementem procesu CI/CD jest monitorowanie wdrożeń, aby szybko wykryć i zareagować na ewentualne problemy:

1. Integracja z usługami monitorowania

# .github/workflows/deploy-and-monitor.yml
name: Deploy and Monitor

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Deploy to Vercel
        uses: amondnet/vercel-action@v20
        with:
          vercel-token: ${{ secrets.VERCEL_TOKEN }}
          vercel-org-id: ${{ secrets.ORG_ID }}
          vercel-project-id: ${{ secrets.PROJECT_ID }}
          vercel-args: '--prod'

      - name: Notify Datadog of deployment
        run: |
          curl -X POST "https://api.datadoghq.com/api/v1/events"           -H "Content-Type: application/json"           -H "DD-API-KEY: ${{ secrets.DATADOG_API_KEY }}"           -d '{"title":"Deployment to production","text":"Deployed commit ${{ github.sha }} to production","tags":["environment:production","team:frontend"],"alert_type":"info"}'

2. Automatyczne testy po wdrożeniu

# .github/workflows/post-deploy-tests.yml
name: Post-deployment Tests

on:
  deployment_status:

jobs:
  smoke-tests:
    if: github.event.deployment_status.state == 'success'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Run smoke tests
        run: |
          npm ci
          npm run test:smoke -- --url=${{ github.event.deployment_status.target_url }}

      - name: Post results to Slack
        if: always()
        uses: slackapi/slack-github-action@v1
        with:
          payload: |
            {
              "text": "Smoke test results: ${{ job.status }}\nDeployment URL: ${{ github.event.deployment_status.target_url }}"
            }
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

Podsumowanie

Implementacja CI/CD dla aplikacji Next.js jest kluczowym elementem nowoczesnego procesu rozwoju oprogramowania, który przynosi wiele korzyści:

  1. Szybsze wdrażanie zmian - automatyzacja procesów skraca czas potrzebny na dostarczenie nowych funkcji
  2. Wyższa jakość kodu - automatyczne testy i analizy kodu zapewniają wyższą jakość
  3. Mniejsze ryzyko błędów - automatyzacja eliminuje błędy ludzkie
  4. Szybszy feedback - deweloperzy otrzymują natychmiastową informację zwrotną o jakości kodu
  5. Zwiększona produktywność - deweloperzy koncentrują się na rozwoju funkcji, a nie na manualnych procesach

Poprawnie skonfigurowany pipeline CI/CD jest inwestycją, która zwraca się w postaci oszczędności czasu, wyższej jakości kodu i bardziej niezawodnych wdrożeń. Niezależnie od wybranej platformy (GitHub Actions, GitLab CI, CircleCI, Jenkins), kluczowe jest dostosowanie procesu do specyficznych potrzeb projektu i zespołu.

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

// Demo: CI/CD i automatyzacja wdrozen
interface PipelineStage {
  id: string;
  name: string;
  icon: string;
  status: 'pending' | 'running' | 'success' | 'failed' | 'skipped';
  duration?: number;
  steps: string[];
}

function CICDDemo() {
  const [stages, setStages] = useState<PipelineStage[]>([
    { id: 'install', name: 'Install', icon: 'I', status: 'pending', steps: ['npm ci', 'Cache dependencies'] },
    { id: 'lint', name: 'Lint', icon: 'L', status: 'pending', steps: ['ESLint', 'Prettier check', 'TypeScript check'] },
    { id: 'test', name: 'Test', icon: 'T', status: 'pending', steps: ['Unit tests', 'Integration tests', 'Coverage report'] },
    { id: 'build', name: 'Build', icon: 'B', status: 'pending', steps: ['next build', 'Bundle analysis', 'Optimize assets'] },
    { id: 'deploy', name: 'Deploy', icon: 'D', status: 'pending', steps: ['Deploy to staging', 'Health check', 'Promote to production'] },
  ]);
  const [activeProvider, setActiveProvider] = useState<'github' | 'gitlab' | 'vercel'>('github');
  const [isRunning, setIsRunning] = useState(false);
  const [failAt, setFailAt] = useState<string>('none');

  const statusColors: Record<string, string> = {
    pending: '#64748b', running: '#f59e0b', success: '#10b981', failed: '#ef4444', skipped: '#8892b0',
  };

  const statusIcons: Record<string, string> = {
    pending: 'o', running: '~', success: 'V', failed: 'X', skipped: '-',
  };

  const runPipeline = async () => {
    setIsRunning(true);
    setStages(prev => prev.map(s => ({ ...s, status: 'pending', duration: undefined })));

    for (let i = 0; i < stages.length; i++) {
      const stage = stages[i];

      setStages(prev => prev.map((s, idx) => idx === i ? { ...s, status: 'running' } : s));

      const duration = Math.floor(Math.random() * 3000) + 1000;
      await new Promise(r => setTimeout(r, duration));

      if (failAt === stage.id) {
        setStages(prev => prev.map((s, idx) =>
          idx === i ? { ...s, status: 'failed', duration } :
          idx > i ? { ...s, status: 'skipped' } : s
        ));
        setIsRunning(false);
        return;
      }

      setStages(prev => prev.map((s, idx) => idx === i ? { ...s, status: 'success', duration } : s));
    }

    setIsRunning(false);
  };

  const ciConfigs: Record<string, string> = {
    github: "# .github/workflows/deploy.yml\nname: Deploy\non:\n  push:\n    branches: [main]\n\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-node@v4\n      - run: npm ci\n      - run: npm run lint\n      - run: npm run test\n      - run: npm run build\n      - run: npx vercel --prod",
    gitlab: "# .gitlab-ci.yml\nstages:\n  - install\n  - lint\n  - test\n  - build\n  - deploy\n\ninstall:\n  stage: install\n  script: npm ci\n  cache:\n    paths: [node_modules/]\n\ntest:\n  stage: test\n  script: npm run test\n\nbuild:\n  stage: build\n  script: npm run build",
    vercel: "// vercel.json\n{\n  \"buildCommand\": \"npm run build\",\n  \"devCommand\": \"npm run dev\",\n  \"installCommand\": \"npm ci\",\n  \"framework\": \"nextjs\",\n  \"github\": {\n    \"autoAlias\": true,\n    \"silent\": true\n  }\n}",
  };

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
      <h1 style={{ color: '#64ffda', marginBottom: '8px' }}>CI/CD Pipeline</h1>
      <p style={{ color: '#8892b0', marginBottom: '24px' }}>Automatyzacja wdrozen aplikacji Next.js</p>

      <div style={{ display: 'flex', gap: '8px', marginBottom: '20px' }}>
        {[
          { id: 'github' as const, label: 'GitHub Actions' },
          { id: 'gitlab' as const, label: 'GitLab CI' },
          { id: 'vercel' as const, label: 'Vercel' },
        ].map(p => (
          <button key={p.id} onClick={() => setActiveProvider(p.id)} style={{
            padding: '8px 16px', borderRadius: '8px', border: 'none', cursor: 'pointer',
            background: activeProvider === p.id ? '#64ffda' : '#1a1a2e', color: activeProvider === p.id ? '#0f0f23' : '#8892b0', fontWeight: 'bold',
          }}>{p.label}</button>
        ))}
      </div>

      <div style={{ background: '#1a1a2e', padding: '20px', borderRadius: '12px', border: '1px solid #333', marginBottom: '24px' }}>
        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px' }}>
          <h3 style={{ color: '#64ffda', margin: 0 }}>Pipeline Stages</h3>
          <div style={{ display: 'flex', gap: '8px', alignItems: 'center' }}>
            <select value={failAt} onChange={e => setFailAt(e.target.value)} style={{ padding: '6px 10px', borderRadius: '6px', background: '#0f0f23', color: '#fff', border: '1px solid #333', fontSize: '12px' }}>
              <option value="none">No failure</option>
              {stages.map(s => <option key={s.id} value={s.id}>Fail at {s.name}</option>)}
            </select>
            <button onClick={runPipeline} disabled={isRunning} style={{ padding: '8px 16px', borderRadius: '6px', background: isRunning ? '#333' : '#64ffda', color: '#0f0f23', border: 'none', cursor: isRunning ? 'default' : 'pointer', fontWeight: 'bold' }}>
              {isRunning ? 'Running...' : 'Run Pipeline'}
            </button>
          </div>
        </div>

        <div style={{ display: 'flex', gap: '16px', alignItems: 'flex-start', flexWrap: 'wrap' }}>
          {stages.map((stage, i) => (
            <React.Fragment key={stage.id}>
              <div style={{ textAlign: 'center', minWidth: '120px' }}>
                <div style={{
                  width: '50px', height: '50px', borderRadius: '50%', margin: '0 auto 8px',
                  border: '3px solid ' + statusColors[stage.status],
                  display: 'flex', alignItems: 'center', justifyContent: 'center',
                  background: stage.status === 'running' ? statusColors[stage.status] + '30' : 'transparent',
                  fontSize: '18px', fontWeight: 'bold', color: statusColors[stage.status],
                }}>
                  {statusIcons[stage.status]}
                </div>
                <div style={{ fontWeight: 'bold', fontSize: '14px', color: statusColors[stage.status] }}>{stage.name}</div>
                {stage.duration && <div style={{ fontSize: '11px', color: '#8892b0' }}>{(stage.duration / 1000).toFixed(1)}s</div>}
                <div style={{ marginTop: '8px' }}>
                  {stage.steps.map((step, j) => (
                    <div key={j} style={{ fontSize: '11px', color: '#555', padding: '1px 0' }}>{step}</div>
                  ))}
                </div>
              </div>
              {i < stages.length - 1 && <div style={{ paddingTop: '20px', color: '#333', fontSize: '20px' }}>-&gt;</div>}
            </React.Fragment>
          ))}
        </div>
      </div>

      <div style={{ background: '#1a1a2e', padding: '16px', borderRadius: '8px', border: '1px solid #333' }}>
        <h3 style={{ color: '#f59e0b', fontSize: '14px', marginTop: 0 }}>Konfiguracja ({activeProvider}):</h3>
        <pre style={{ fontSize: '12px', color: '#e0e0e0', margin: 0, overflow: 'auto', whiteSpace: 'pre-wrap' }}>{ciConfigs[activeProvider]}</pre>
      </div>
    </div>
  );
}

export default CICDDemo;

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. CI/CD oznacza:

  2. 2. Jaka jest różnica między Continuous Delivery a Continuous Deployment?

Zadania praktyczne w grze

  • Edytor kodu

    Utwórz workflow GitHub Actions uruchamiany przy pushu na gałąź main: checkout, setup-node, instalacja zależności, testy, build, a na końcu deployment na Vercel z tokenem z sekretu VERCEL_TOKEN.

  • Układanie w pionie

    Ułóż elementy w prawidłowej kolejności: Code push → Run tests → Build app

  • Układanie w pionie

    Ułóż składnię konfiguracji triggera GitHub Actions workflow:

  • Edytor kodu

    Utwórz health check API endpoint z database connectivity, external services status i system metrics

  1. PytanieCI/CD oznacza:
  2. Zadanie z kodemPraktyka: workflow GitHub Actions z deploymentem na Vercel
  3. Ułóż w kolejnościKolejność: Code push → Run tests → Build app
  4. PytanieContinuous Delivery vs Continuous Deployment
  5. Ułóż w kolejnościSkładnia GitHub Actions workflow trigger
  6. Zadanie z kodemPraktyka: Utwórz health check API endpoint z database

Przydatne artykuły