Завантаження тестування ASP.NET Core Applications з k6: Практичною Implementation (Українська (Ukrainian))

Завантаження тестування ASP.NET Core Applications з k6: Практичною Implementation

Tuesday, 02 December 2025

//

37 minute read

Тепер, коли ви розумієте основи k6 і тестування рівня продуктивності ,, настав час втілити ці знання у реальність МSK3 В цій статті ми прокладаємо шлях до написання справжніх тестівМSK4 інтеграції їх у схему CIM SK5 ЦД трубок, та використання інструментів обробки profili для виявлення та виправлення недоліків рівня продуктивностiMSC7

Це Частина 2 série з двох частин для тестування на навантаження з k6:

  • Частина 1: Вprowadzenie: Вprowadzenie до kM SK1 інсталяції , типів тесту МSK3 і чому kМSK4
  • Частина 2 МSK1 цей artykułM SK2: Тести на написання , CIM SK2 інтеграція з компакт-диском МSK3 розробка профилів M SK4 і реальні приклади

Якщо ви ще не прочитали', то почнете з частини МSK1 і зрозумієте там базові речіM SK3 інсталяцію МSK4 та типи тестів перед тим, як почати реалізувати .

Налагодження середовища для тестування

Перед запуском тестів k6 tests , дозвольтеM SK2s встановити MinimalBlog для тестування:

1. Запустити MinimalBlog локально

Використовуючи демонстраційний проект:

cd Mostlylucid.MinimalBlog.Demo
dotnet run

Або за допомогою Докера:

docker run -d -p 5000:8080 \
  -v $(pwd)/Markdown:/app/Markdown \
  --name minimalblog-test \
  scottgal/minimalblog:latest

Чому режим випуску має значення для тестування ефективності

Для точного тестування ефективності, завжди будувати в trybie випуску:

dotnet run --configuration Release

Різниця між розладами і режимом релізу:

Aspect МSK1 Mode Debug Mode Release МSK3
Оптимізації Замкнуто Повні оптимізації JIT включені МSK2
Вказування Minimal МSK1 Agгресивна методика, в якій замальовується
Смертий код Зачуваний МSK1 Виключений МSK2
Символи розладів Полне PDB МSK1 додаткові метадані МSK2 Minimalно або жодне
Заперечення Debug.Assert() активний С Compiled out МSK1
Перевірка кордонів Додаткові перевірки безпеки
Типові накладні витрати МSK0 2-10x повільніше МSK2 Базова продуктивність

Чому режим Debug дає хибні результати:

  1. Жодної оптимізації JIT: Компілятор зберігає структуру коду для виправ, а не оптимізує швидкість
  2. Додаткові інструменти: Побудові деbugу включають код для розбіжних точок , змінна інспектація M SK2 та сліди стека
  3. Немає вказівок: Методи не запрограмованіM SK1 не вбудовані , додаючи накладні витрати на телефонний дзвінок, які з 'явились в процесі виробництва
  4. Виведення твердження: Debug.Assert() вказівки виконувати, додаючи перевірки, що виробництво не буде
  5. Різні моделі пам 'яті: Приdziałи відладів включають упакування та відстеження, що впливає на поведінку GC

Коли використовувати режим Debug для тестування:

  • Невдачі у розв 'язанні проблем: Коли тести провалюються і вам потрібні деталізовані сліди стека
  • Розслідування конкретних запитів: Додайте виправника, щоб відстежити одну проблему
  • Перевірка журналування: Упевниться, що ваш журнал бере правильну інформацію під завантаженням
  • Початковий розвиток: Коли пишеш нові тестові сценарії і перевіряєш, чи вони досягають правильного кінцевого результату

Рекомендується робочий процес:

# 1. Develop and debug with Debug mode
dotnet run                           # Debug mode (default)

# 2. Validate functionality works
k6 run --vus 1 --duration 10s smoke-test.js

# 3. Switch to Release for actual performance testing
dotnet run -c Release

# 4. Run full load tests
k6 run load-test.js

Правило палець: Якщо виM SK1 вимірюєте продуктивність , використовуєте реліз МSK3 якщо ви МSK4 виправляєте помилки

2. Подготуйте дані тесту

Створити декілька позначених постів для тестування з:

# Create test posts directory
mkdir -p TestMarkdown

# Create sample posts
for i in {1..10}; do
  cat > TestMarkdown/test-post-$i.md <<EOF
# Test Post $i




This is test post number $i with some **bold** text and *italic* text.

## Sample Content

- Item 1
- Item 2
- Item 3

\`\`\`csharp
public class Test {
    public int Value { get; set; }
}
\`\`\`
EOF
done

3. Створити каталог тестових сценаріїв

mkdir k6-tests
cd k6-tests

Тепер ми - МСК0 - готові написати наші тести

Тест 1: Випробовування fumу

Дозвольте почати з простого тесту на дихання, щоб перевірити базову функцію

Файл: smoke-test.js

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  vus: 1,
  duration: '30s',
  thresholds: {
    http_req_duration: ['p(95)<500'], // 95% of requests should be below 500ms
    http_req_failed: ['rate<0.01'],    // Less than 1% errors
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:5000';

export default function() {
  // Test homepage
  let response = http.get(`${BASE_URL}/`);
  check(response, {
    'homepage status is 200': (r) => r.status === 200,
    'homepage has content': (r) => r.body.length > 0,
    'homepage response time OK': (r) => r.timings.duration < 500,
  });

  sleep(1);

  // Test a single post
  response = http.get(`${BASE_URL}/post/test-post-1`);
  check(response, {
    'post status is 200': (r) => r.status === 200,
    'post has content': (r) => r.body.length > 0,
    'post contains title': (r) => r.body.includes('Test Post 1'),
  });

  sleep(1);

  // Test categories page
  response = http.get(`${BASE_URL}/categories`);
  check(response, {
    'categories status is 200': (r) => r.status === 200,
    'categories has content': (r) => r.body.length > 0,
  });

  sleep(1);

  // Test category filter
  response = http.get(`${BASE_URL}/category/Testing`);
  check(response, {
    'category filter status is 200': (r) => r.status === 200,
    'category has posts': (r) => r.body.includes('Test Post'),
  });
}

Пройти тест:

k6 run smoke-test.js

Очікуваний результат:

     ✓ homepage status is 200
     ✓ homepage has content
     ✓ homepage response time OK
     ✓ post status is 200
     ✓ post has content
     ✓ post contains title
     ✓ categories status is 200
     ✓ categories has content
     ✓ category filter status is 200
     ✓ category has posts

     checks.........................: 100.00% ✓ 300  ✗ 0
     data_received..................: 1.2 MB  40 kB/s
     data_sent......................: 15 kB   500 B/s
     http_req_duration..............: avg=45ms min=12ms med=38ms max=156ms p(95)=98ms
     http_reqs......................: 120     4/s

Випробування 2: Випробовування перевірки таємниці

MinimalBlog'Performance сильно залежить від Caching . LetM SK2s verify it works:

Файл: cache-test.js

import http from 'k6/http';
import { check, group } from 'k6';

export const options = {
  vus: 1,
  iterations: 10,
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:5000';

export default function() {
  group('Memory Cache Test - First Request', () => {
    const start = Date.now();
    const response = http.get(`${BASE_URL}/post/test-post-1`);
    const duration = Date.now() - start;

    check(response, {
      'first request successful': (r) => r.status === 200,
    });

    console.log(`First request: ${duration}ms`);
  });

  group('Memory Cache Test - Cached Request', () => {
    const start = Date.now();
    const response = http.get(`${BASE_URL}/post/test-post-1`);
    const duration = Date.now() - start;

    check(response, {
      'cached request successful': (r) => r.status === 200,
      'cached request is faster': (r) => r.timings.duration < 100,
    });

    console.log(`Cached request: ${duration}ms`);
  });

  group('Output Cache Headers', () => {
    const response = http.get(`${BASE_URL}/post/test-post-1`);

    check(response, {
      'has cache headers': (r) => r.headers['Cache-Control'] !== undefined,
      'output cache working': (r) => {
        const age = r.headers['Age'];
        return age !== undefined && parseInt(age) >= 0;
      },
    });

    console.log(`Cache-Control: ${response.headers['Cache-Control']}`);
    console.log(`Age: ${response.headers['Age']}`);
  });
}

Пройти тест:

k6 run cache-test.js

Цей тест покаже вам:

  1. Перше очікування ( коли кэш холоднийM SK1
  2. Наступні строки запиту (горячий таємникM SK1
  3. Перевірка заголовків 缓шів

Тест 3: Тест завантаження

Тепер попробуймо МСК0 під реальним навантаженням

Файл: load-test.js

import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate } from 'k6/metrics';

// Custom metrics
const errorRate = new Rate('errors');

export const options = {
  stages: [
    { duration: '2m', target: 10 },   // Ramp up to 10 users
    { duration: '5m', target: 10 },   // Stay at 10 users
    { duration: '2m', target: 0 },    // Ramp down to 0
  ],
  thresholds: {
    http_req_duration: ['p(95)<300'],  // 95% under 300ms
    http_req_failed: ['rate<0.01'],     // Less than 1% errors
    errors: ['rate<0.1'],               // Less than 10% errors
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:5000';

const scenarios = [
  { weight: 50, path: '/' },                    // 50% homepage
  { weight: 30, path: '/post/test-post-1' },    // 30% specific post
  { weight: 10, path: '/categories' },          // 10% categories
  { weight: 10, path: '/category/Testing' },    // 10% category filter
];

function weightedChoice(scenarios) {
  const total = scenarios.reduce((sum, s) => sum + s.weight, 0);
  let random = Math.random() * total;

  for (const scenario of scenarios) {
    random -= scenario.weight;
    if (random <= 0) return scenario;
  }

  return scenarios[0];
}

export default function() {
  const scenario = weightedChoice(scenarios);
  const response = http.get(`${BASE_URL}${scenario.path}`);

  const success = check(response, {
    'status is 200': (r) => r.status === 200,
    'response time OK': (r) => r.timings.duration < 500,
    'has content': (r) => r.body.length > 0,
  });

  errorRate.add(!success);

  sleep(Math.random() * 2 + 1); // Random sleep 1-3 seconds
}

Пройти тест:

k6 run load-test.js

Результати перекладу:

scenarios: (100.00%) 1 scenario, 10 max VUs, 9m30s max duration
  default: 2m00s ramp-up, 5m00s plateau, 2m00s ramp-down

     ✓ status is 200
     ✓ response time OK
     ✓ has content

     checks.........................: 100.00% ✓ 3450  ✗ 0
     data_received..................: 12 MB   22 kB/s
     data_sent......................: 132 kB  244 B/s
     errors.........................: 0.00%   ✓ 0     ✗ 1150
     http_req_duration..............: avg=42ms min=8ms med=35ms max=245ms p(95)=86ms p(99)=156ms
     http_reqs......................: 1150    2.12/s
     iteration_duration.............: avg=2.1s min=1.0s med=2.0s max=3.4s
     vus............................: 10      min=0   max=10

Найголовні метрики для перегляду:

  • http_req_duration pM SK2МSK0 95десятий процентний час реагування МSK2 має бути нижче шкали )
  • http_req_failed: Рівень помилок ( має бути близьким МSK2
  • http_reqs: Общая пропускна спроможність

Тест 4: Стрессний тест

Дозвольте знайти MinimalBlog'переломний моментM SK2

Файл: stress-test.js

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 10 },    // Normal load
    { duration: '2m', target: 50 },    // Increase to 50
    { duration: '2m', target: 100 },   // Stress at 100
    { duration: '2m', target: 200 },   // High stress at 200
    { duration: '3m', target: 0 },     // Recovery
  ],
  thresholds: {
    http_req_duration: ['p(99)<3000'], // 99% under 3s even under stress
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:5000';

export default function() {
  const responses = http.batch([
    ['GET', `${BASE_URL}/`],
    ['GET', `${BASE_URL}/post/test-post-1`],
    ['GET', `${BASE_URL}/post/test-post-2`],
    ['GET', `${BASE_URL}/categories`],
  ]);

  responses.forEach((response, index) => {
    check(response, {
      [`request ${index} status is 200`]: (r) => r.status === 200,
    });
  });

  sleep(0.5);
}

export function handleSummary(data) {
  return {
    'stress-test-summary.json': JSON.stringify(data),
    stdout: textSummary(data, { indent: ' ', enableColors: true }),
  };
}

Пройти тест:

k6 run stress-test.js

Дивіться на:

  • Коли час реагування починає деградувати?
  • На якій позначці VU з 'являються помилки?
  • Чи відновлюється система після зниження навантаження?

Тест 5: Тест Spike

Випробуй неочікувані крахи дорожнього руху ( так само, як вони показують на Reddit чи Hacker News ):

Файл: spike-test.js

import http from 'k6/http';
import { check } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 10 },    // Normal traffic
    { duration: '30s', target: 200 },  // Sudden spike!
    { duration: '3m', target: 200 },   // Sustained spike
    { duration: '1m', target: 10 },    // Back to normal
    { duration: '1m', target: 0 },     // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<1000'], // Allow higher latency during spike
    http_req_failed: ['rate<0.05'],     // Allow 5% errors during spike
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:5000';

export default function() {
  const response = http.get(`${BASE_URL}/`);

  check(response, {
    'status is 200 or 503': (r) => r.status === 200 || r.status === 503,
  });
}

Пройти тест:

k6 run spike-test.js

Цей тест перевіряє:

  • Чи працює система з несподіваним навантаженням?
  • Чи існують відповідні механізми обмеження ставки?
  • Чи він відновлюється граційно?

Випробовування 6:

Довгий-випробування, щоб виявити витіки пам 'яті або вичерпання ресурсів

Файл: soak-test.js

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 20 },    // Ramp up
    { duration: '3h', target: 20 },    // Stay at 20 for 3 hours
    { duration: '2m', target: 0 },     // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],
    http_req_failed: ['rate<0.01'],
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:5000';

export default function() {
  const response = http.get(`${BASE_URL}/post/test-post-${Math.floor(Math.random() * 10) + 1}`);

  check(response, {
    'status is 200': (r) => r.status === 200,
    'response time stable': (r) => r.timings.duration < 500,
  });

  sleep(2);
}

Пройти тест:

k6 run soak-test.js

Важливо: Наблюдайте за ресурсами системи під час тестів на поглинання

# In another terminal
watch -n 5 'dotnet-counters ps | grep -i minimal'

# Or use top/htop
htop -p $(pgrep -f MinimalBlog)

Дивіться на:

  • Повільне збільшення пам 'яті (відтік пам' ятіM SK1
  • Використовування процесора зростає
  • Відповідальний час погіршується з часом

Тест 7: Реальність польоту

Створити поведінку користувача

Файл: user-journey-test.js

import http from 'k6/http';
import { check, group, sleep } from 'k6';
import { htmlReport } from 'https://raw.githubusercontent.com/benc-uk/k6-reporter/main/dist/bundle.js';

export const options = {
  vus: 10,
  duration: '5m',
  thresholds: {
    'group_duration{group:::01_homepage}': ['avg<500'],
    'group_duration{group:::02_browse_posts}': ['avg<500'],
    'group_duration{group:::03_categories}': ['avg<500'],
  },
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:5000';

export default function() {
  // Simulate a real user journey

  group('01_homepage', () => {
    const response = http.get(`${BASE_URL}/`);
    check(response, {
      'homepage loaded': (r) => r.status === 200,
      'homepage has posts': (r) => r.body.includes('Test Post'),
    });
    sleep(Math.random() * 3 + 2); // Read homepage 2-5 seconds
  });

  group('02_browse_posts', () => {
    // User clicks on a post
    let response = http.get(`${BASE_URL}/post/test-post-1`);
    check(response, {
      'post loaded': (r) => r.status === 200,
      'post has content': (r) => r.body.length > 500,
    });
    sleep(Math.random() * 20 + 10); // Read post 10-30 seconds

    // User clicks another post
    response = http.get(`${BASE_URL}/post/test-post-2`);
    check(response, {
      'second post loaded': (r) => r.status === 200,
    });
    sleep(Math.random() * 15 + 5); // Read second post 5-20 seconds
  });

  group('03_categories', () => {
    // User explores categories
    const response = http.get(`${BASE_URL}/categories`);
    check(response, {
      'categories loaded': (r) => r.status === 200,
    });
    sleep(2);

    // User clicks a category
    const categoryResponse = http.get(`${BASE_URL}/category/Testing`);
    check(categoryResponse, {
      'category posts loaded': (r) => r.status === 200,
      'category has posts': (r) => r.body.includes('Test Post'),
    });
    sleep(Math.random() * 10 + 5); // Browse category 5-15 seconds
  });
}

export function handleSummary(data) {
  return {
    'user-journey-report.html': htmlReport(data),
  };
}

Пройти тест:

k6 run user-journey-test.js

Це створює HTML звіт: user-journey-report.html

Заawansовані: тестування API MetaWeblog

Якщо ви включили MetaWeblog, перевірили його також:

Файл: metaweblog-test.js

import http from 'k6/http';
import { check } from 'k6';
import encoding from 'k6/encoding';

export const options = {
  vus: 1,
  iterations: 10,
};

const BASE_URL = __ENV.BASE_URL || 'http://localhost:5000';
const USERNAME = __ENV.USERNAME || 'admin';
const PASSWORD = __ENV.PASSWORD || 'changeme';

function createXmlRpcRequest(methodName, params) {
  return `<?xml version="1.0"?>
<methodCall>
  <methodName>${methodName}</methodName>
  <params>
    ${params}
  </params>
</methodCall>`;
}

export default function() {
  // Test getRecentPosts
  const recentPostsXml = createXmlRpcRequest('blogger.getRecentPosts', `
    <param><value><string>0</string></value></param>
    <param><value><string>${USERNAME}</string></value></param>
    <param><value><string>${PASSWORD}</string></value></param>
    <param><value><int>10</int></value></param>
  `);

  const response = http.post(`${BASE_URL}/metaweblog`, recentPostsXml, {
    headers: { 'Content-Type': 'text/xml' },
  });

  check(response, {
    'MetaWeblog API responds': (r) => r.status === 200,
    'MetaWeblog returns XML': (r) => r.body.includes('<?xml'),
    'MetaWeblog has methodResponse': (r) => r.body.includes('methodResponse'),
  });
}

Пройти тест:

k6 run -e USERNAME=admin -e PASSWORD=yourpassword metaweblog-test.js

Випробування в CI/CD

Використовуючи k6 як Quality Gate

Найпотужніше застосування k6 в CIM SK1CD є якісні ворота - автоматично не вдається будувати, якщо продуктивність погіршується . Ось як реалізувати комплексні тестування kM SK3 у GitHub Actions

Акція GitHub: Базова перевірка

Дозвольте's розпочати з базового робочого потоку, який працює на кожному потязі і блокує складання, якщо тести провалюються

Створити .github/workflows/k6-pr-check.yml:

name: k6 Performance Check

on:
  pull_request:
    branches: [ main ]

jobs:
  performance-check:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.0.x'

      - name: Setup k6
        run: |
          sudo gpg -k
          sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg \
            --keyserver hkp://keyserver.ubuntu.com:80 \
            --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
          echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | \
            sudo tee /etc/apt/sources.list.d/k6.list
          sudo apt-get update
          sudo apt-get install k6

      - name: Create test data
        run: |
          mkdir -p TestMarkdown
          for i in {1..10}; do
            cat > TestMarkdown/test-post-$i.md <<EOF
          # Test Post $i
          
          

          This is test post $i with **bold** and *italic* text.

          \`\`\`csharp
          public class Test { public int Value { get; set; } }
          \`\`\`
          EOF
          done

      - name: Build MinimalBlog
        run: |
          cd Mostlylucid.MinimalBlog.Demo
          dotnet build --configuration Release

      - name: Start MinimalBlog
        run: |
          cd Mostlylucid.MinimalBlog.Demo
          dotnet run --configuration Release &
          echo $! > app.pid

          # Wait for app to be ready
          timeout 60 bash -c 'until curl -sf http://localhost:5000 > /dev/null; do
            echo "Waiting for app..."
            sleep 2
          done'

          echo "- App is ready!"

      - name: Run Smoke Test
        id: smoke-test
        run: |
          k6 run --out json=smoke-results.json k6-tests/smoke-test.js
          echo "smoke-test-passed=true" >> $GITHUB_OUTPUT

      - name: Run Load Test
        id: load-test
        run: |
          k6 run --out json=load-results.json k6-tests/load-test.js
          echo "load-test-passed=true" >> $GITHUB_OUTPUT

      - name: Run Cache Test
        id: cache-test
        run: |
          k6 run --out json=cache-results.json k6-tests/cache-test.js
          echo "cache-test-passed=true" >> $GITHUB_OUTPUT

      - name: Stop MinimalBlog
        if: always()
        run: |
          if [ -f Mostlylucid.MinimalBlog.Demo/app.pid ]; then
            kill $(cat Mostlylucid.MinimalBlog.Demo/app.pid) || true
          fi

      - name: Upload Test Results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: k6-test-results
          path: |
            *-results.json
            *.html
          retention-days: 30

      - name: Check Test Results
        if: always()
        run: |
          echo "## k6 Performance Test Results" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY

          if [ "${{ steps.smoke-test.outputs.smoke-test-passed }}" == "true" ]; then
            echo "- Smoke Test: PASSED" >> $GITHUB_STEP_SUMMARY
          else
            echo "- Smoke Test: FAILED" >> $GITHUB_STEP_SUMMARY
          fi

          if [ "${{ steps.load-test.outputs.load-test-passed }}" == "true" ]; then
            echo "- Load Test: PASSED" >> $GITHUB_STEP_SUMMARY
          else
            echo "- Load Test: FAILED" >> $GITHUB_STEP_SUMMARY
          fi

          if [ "${{ steps.cache-test.outputs.cache-test-passed }}" == "true" ]; then
            echo "- Cache Test: PASSED" >> $GITHUB_STEP_SUMMARY
          else
            echo "- Cache Test: FAILED" >> $GITHUB_STEP_SUMMARY
          fi

Ключові характеристики:

  • Працює на кожному PR
  • Створює дані тесту автоматично
  • чекає, поки програма готова до тестування
  • Використовує багато типів тесту
  • Не вдається будувати, якщо порог не досягнутий
  • завантажує результати як артефакти
  • Показує резюме в інтерфейсі GitHub
sequenceDiagram
    participant PR as Pull Request
    participant GHA as GitHub Actions
    participant App as MinimalBlog
    participant k6 as k6 Tests

    PR->>GHA: Trigger workflow
    GHA->>GHA: Setup .NET & k6
    GHA->>GHA: Create test data
    GHA->>App: Build & Start
    App-->>GHA: App ready
    GHA->>k6: Run smoke test
    k6-->>GHA: Results
    GHA->>k6: Run load test
    k6-->>GHA: Results
    GHA->>k6: Run cache test
    k6-->>GHA: Results
    GHA->>App: Stop
    alt Tests Pass
        GHA->>PR: Mark as success
    else Tests Fail
        GHA->>PR: Block merge
    end

Акції GitHub: Заawansовані з коментаріми до ЗМІ

Створити .github/workflows/k6-pr-comment.yml щоб опублікувати результати як PR коментарі:

name: k6 Performance with PR Comment

on:
  pull_request:
    branches: [ main ]

permissions:
  pull-requests: write
  contents: read

jobs:
  performance-test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.0.x'

      - name: Setup k6
        uses: grafana/setup-k6-action@v1

      - name: Create test data
        run: |
          mkdir -p TestMarkdown
          for i in {1..10}; do
            cat > TestMarkdown/test-post-$i.md <<EOF
          # Test Post $i
          
          
          Test content for post $i.
          EOF
          done

      - name: Build and Start App
        run: |
          cd Mostlylucid.MinimalBlog.Demo
          dotnet build -c Release
          dotnet run -c Release > app.log 2>&1 &
          APP_PID=$!
          echo $APP_PID > app.pid

          timeout 60 bash -c 'until curl -sf http://localhost:5000; do sleep 2; done'

      - name: Run k6 Tests
        id: k6-test
        run: |
          # Run tests and capture output
          k6 run --out json=results.json k6-tests/load-test.js > k6-output.txt 2>&1 || true

          # Parse results
          if grep -q "✓" k6-output.txt; then
            echo "tests-passed=true" >> $GITHUB_OUTPUT
          else
            echo "tests-passed=false" >> $GITHUB_OUTPUT
          fi

          # Extract key metrics
          P95=$(grep "http_req_duration" k6-output.txt | grep -oP 'p\(95\)=\K[0-9.]+' || echo "N/A")
          RPS=$(grep "http_reqs" k6-output.txt | grep -oP '\d+\.\d+/s' || echo "N/A")
          ERRORS=$(grep "http_req_failed" k6-output.txt | grep -oP '\d+\.\d+%' || echo "0%")

          echo "p95=${P95}" >> $GITHUB_OUTPUT
          echo "rps=${RPS}" >> $GITHUB_OUTPUT
          echo "errors=${ERRORS}" >> $GITHUB_OUTPUT

      - name: Comment PR
        uses: actions/github-script@v7
        if: always()
        with:
          script: |
            const fs = require('fs');
            const output = fs.readFileSync('k6-output.txt', 'utf8');

            const testsPassed = '${{ steps.k6-test.outputs.tests-passed }}' === 'true';
            const icon = testsPassed ? 'PASS' : 'FAIL';
            const status = testsPassed ? 'PASSED' : 'FAILED';

            const comment = `## ${icon} k6 Performance Test Results

            **Status:** ${status}

            ### Key Metrics
            | Metric | Value |
            |--------|-------|
            | P95 Response Time | ${{ steps.k6-test.outputs.p95 }}ms |
            | Requests/sec | ${{ steps.k6-test.outputs.rps }} |
            | Error Rate | ${{ steps.k6-test.outputs.errors }} |

            ### Thresholds
            - P95 < 300ms
            - Error rate < 1%

            <details>
            <summary>Full k6 Output</summary>


            \`\`\`
            ${output}
            \`\`\`

            </details>

            [View full test results](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
            `;

            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: comment
            });

      - name: Stop App
        if: always()
        run: |
          [ -f Mostlylucid.MinimalBlog.Demo/app.pid ] && \
            kill $(cat Mostlylucid.MinimalBlog.Demo/app.pid) || true

      - name: Upload Artifacts
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: k6-results
          path: |
            results.json
            k6-output.txt
            Mostlylucid.MinimalBlog.Demo/app.log

Цей робочий процес:

  • Результати постів прямі до PR
  • Показує ключові метрики в таблиці
  • Додає повний результат у розширюваній секції
  • Ссылки на повний тест
  • Індикатори візуального стану

Акція GitHub: Викриття регресії

Створити .github/workflows/k6-baseline.yml для виявлення регресії ефективності:

name: Performance Regression Check

on:
  pull_request:
    branches: [ main ]

jobs:
  regression-check:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout PR code
        uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '9.0.x'

      - name: Setup k6
        uses: grafana/setup-k6-action@v1

      - name: Create test data
        run: |
          mkdir -p TestMarkdown
          for i in {1..20}; do
            echo "# Test Post $i" > TestMarkdown/test-$i.md
            echo "" >> TestMarkdown/test-$i.md
            echo '' >> TestMarkdown/test-$i.md
            echo "Test content $i" >> TestMarkdown/test-$i.md
          done

      - name: Test PR Branch
        run: |
          cd Mostlylucid.MinimalBlog.Demo
          dotnet build -c Release
          dotnet run -c Release &
          APP_PID=$!

          timeout 60 bash -c 'until curl -sf http://localhost:5000; do sleep 2; done'

          # Run test and save results
          k6 run --summary-export=pr-results.json k6-tests/load-test.js

          kill $APP_PID
          sleep 5

      - name: Checkout main branch
        uses: actions/checkout@v4
        with:
          ref: main
          path: baseline

      - name: Test Baseline (main branch)
        run: |
          cd baseline/Mostlylucid.MinimalBlog.Demo
          dotnet build -c Release
          dotnet run -c Release &
          APP_PID=$!

          timeout 60 bash -c 'until curl -sf http://localhost:5000; do sleep 2; done'

          # Run test and save results
          k6 run --summary-export=baseline-results.json ../k6-tests/load-test.js

          kill $APP_PID

      - name: Compare Results
        run: |
          # Extract P95 from both runs
          PR_P95=$(jq '.metrics.http_req_duration.values["p(95)"]' pr-results.json)
          BASE_P95=$(jq '.metrics.http_req_duration.values["p(95)"]' baseline/baseline-results.json)

          # Calculate percentage change
          CHANGE=$(echo "scale=2; (($PR_P95 - $BASE_P95) / $BASE_P95) * 100" | bc)

          echo "## Performance Comparison" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "| Branch | P95 Response Time |" >> $GITHUB_STEP_SUMMARY
          echo "|--------|-------------------|" >> $GITHUB_STEP_SUMMARY
          echo "| main (baseline) | ${BASE_P95}ms |" >> $GITHUB_STEP_SUMMARY
          echo "| PR | ${PR_P95}ms |" >> $GITHUB_STEP_SUMMARY
          echo "| Change | ${CHANGE}% |" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY

          # Fail if performance degrades by more than 20%
          if (( $(echo "$CHANGE > 20" | bc -l) )); then
            echo "- Performance degraded by ${CHANGE}%" >> $GITHUB_STEP_SUMMARY
            echo "::error::Performance regression detected: ${CHANGE}% slower than baseline"
            exit 1
          else
            echo "- Performance acceptable" >> $GITHUB_STEP_SUMMARY
          fi

Цей робочий процес:

  • Випробовує як PR, так і головний відділ
  • Порівнює показники ефективності
  • Не спрацьовує, якщо продуктивність погіршується >20%
  • Захищає повільне поєднання коду
graph TD
    A[PR Submitted] --> B[Checkout PR Code]
    B --> C[Test PR Branch]
    C --> D[Checkout main Branch]
    D --> E[Test Baseline]
    E --> F{Calculate<br/>Difference}
    F -->|>20% Slower| G[FAIL Build]
    F -->|<20% Change| H[PASS Build]
    G --> I[Block Merge]
    H --> J[Allow Merge]

    style G stroke:#ff6b6b
    style H stroke:#51cf66

Найкращі практики для тестування CI/CD kM SK1

  1. Почнемо швидше, Вчасно

    • Спершу проводимо тести на куріння (30sM SK1
    • Пройти повні тести, якщо кур проходить
    • Не вдалось швидко заpisać хвилини CI
  2. Використовуйте відповідних меж

    // Too strict for CI
    thresholds: { http_req_duration: ['p(95)<100'] }
    
    // Good for CI
    thresholds: {
      http_req_duration: ['p(95)<300', 'p(99)<1000'],
      http_req_failed: ['rate<0.01']
    }
    
  3. Відлежність відキャッシュа

    - name: Cache .NET packages
      uses: actions/cache@v4
      with:
        path: ~/.nuget/packages
        key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj') }}
    
  4. Збирати журнали для невдачливих тестів

    - name: Upload App Logs
      if: failure()
      uses: actions/upload-artifact@v4
      with:
        name: app-logs
        path: Mostlylucid.MinimalBlog.Demo/app.log
    
  5. Використовуйте Environment-конкретні пороги

    const isPR = __ENV.GITHUB_EVENT_NAME === 'pull_request';
    
    export const options = {
      thresholds: {
        http_req_duration: isPR
          ? ['p(95)<500']  // Relaxed for PR
          : ['p(95)<300'], // Strict for main
      },
    };
    

Monitoring k6 Tests with Grafana

Для заawansованого стеження, ви можете завантажити kM SK1 метрики до Grafana:

1. Установка Prometheus і Grafana

докер-композиціяM SK1yml для моніторингу:

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    depends_on:
      - prometheus

2. Запустити kM SK1 з Output Prometheus

k6 run --out experimental-prometheus-rw load-test.js

3. Импорт kM SK1 Панель в графані

  1. Доступ до графани в http://localhost:3000
  2. Додайте вихідний код Prometheus
  3. В voer k6 панель управления M SK1ID: 18030)

Перевод k6 Метрії

Ключевые метрики для розуміння:

Метріка часу реагування

  • http_reqM SK1тривалість: Весь час, проведений за запитом
    • avg: Середній час реагування
    • min/max: Найшвидший / найнижчий відгук
    • medМSK0 Середній (50десятий відсоток МSK2
    • p(90)МSK0 90десятий процент
    • p(95)МSK0 95десятий процент МSK2добрі метрики SLA )
    • p(99)МSK0 99 третя відсоткина МSK2 винятки відlovів )

Хороші цінності для MinimalBlog:

  • p(95) M SK1 ≥300 ms для закодованого контенту
  • p(95) < M SK2 ms для перших-завантаження

Пропускна здатність

  • http_reqs: Перечень запитів
  • http_reqM SK1rate: Запити на секунду
  • ітерація_тривалість: Час на одну повну ітерацію

Метрічні помилки

  • http_req_failed: Невдачі запити (4xxM SK2 МSK3xx≥)
  • перевірки: Пропуск затвердженняM SK1рейс невдачі

Метка: M SK1 ♫ ♫ МSK2 ♫ рівень помилок

Передача даних

  • отримані дані: завантажені дані
  • дані_sent: Завантаження даних

Найкращі практики тестування MinimalBlog

1. Тест у ізоляції

Випробуйте MinimalBlog окремо від інших сервісів:

# Stop other services
docker-compose down

# Run only MinimalBlog
dotnet run --project Mostlylucid.MinimalBlog.Demo

2. Використовуйте реальні дані

Не тестуйте з пустими файлами відмітки. Використовуйте реалістичний зміст

  • Різні довжини листівок (короткий, середнійM SK2 довгийMSC3
  • Різні позначки: ( кодові блоки , зображення
  • Багато категорій
  • Реальний-розподіл постів у світі

3. Очевидно тестувати поведінкуキャッシュа

MinimalBlog'Performance relies on caching

// Test cold cache
export function setup() {
  // Clear cache by restarting app or waiting for expiration
}

// Test warm cache
export default function() {
  // First request (cache miss)
  http.get(`${BASE_URL}/post/test-1`);

  // Second request (cache hit)
  const cached = http.get(`${BASE_URL}/post/test-1`);
  check(cached, {
    'cache hit is faster': (r) => r.timings.duration < 50,
  });
}

4. Ресурси системи спостереження

Проведіть їх разом з тестами k6

# CPU and memory
htop

# .NET metrics
dotnet-counters monitor -p $(pgrep -f MinimalBlog)

# GC collections
dotnet-counters monitor --counters System.Runtime[gc-heap-size,gen-0-gc-count,gen-1-gc-count,gen-2-gc-count]

5. Установити реальні пороги

Не встановляйте надто жорсткі або занадто розслаблені ліміти

export const options = {
  thresholds: {
    // Too strict (will fail unnecessarily)
    // http_req_duration: ['p(95)<50'],

    // Too loose (won't catch problems)
    // http_req_duration: ['p(95)<5000'],

    // Just right for MinimalBlog
    http_req_duration: ['p(95)<300', 'p(99)<1000'],
    http_req_failed: ['rate<0.01'],
    checks: ['rate>0.95'],
  },
};

6. Випробовуємо різні сценарії

// Homepage (list view)
http.get(`${BASE_URL}/`);

// Individual posts (detail view)
http.get(`${BASE_URL}/post/getting-started`);

// Categories (filtering)
http.get(`${BASE_URL}/category/Tutorial`);

// Non-existent posts (error handling)
http.get(`${BASE_URL}/post/does-not-exist`);

7. Версия Ваши тести

Витримуй тести разом з кодом:

Mostlylucid.MinimalBlog/
├── k6-tests/
│   ├── smoke-test.js
│   ├── load-test.js
│   ├── stress-test.js
│   ├── spike-test.js
│   ├── soak-test.js
│   ├── cache-test.js
│   └── user-journey-test.js
├── .github/
│   └── workflows/
│       └── k6-tests.yml
└── README-TESTING.md

Полегшення поширених проблем

Питання 1: Зв 'язок відторгнутий

Проблема:

WARN[0000] Request Failed error="Get \"http://localhost:5000/\": dial tcp [::1]:5000: connect: connection refused"

Рішення:

# Verify MinimalBlog is running
curl http://localhost:5000

# Check correct port
netstat -an | grep 5000

# Use correct URL
k6 run -e BASE_URL=http://localhost:5173 smoke-test.js

Випуск 2: високий рівень помилок

Проблема:

✗ http_req_failed: 45.23% (threshold is < 1%)

Рішення:

  1. Проверяйте журнали застосування за помилками
  2. Перевірити, чи існують дані тесту (markdown filesM SK1
  3. Скорінити кількість VU (можливо надмірне навантаженняM SK1
  4. Збільшити czas на підйомку

Публикація 3: Повільні часи реагування

Проблема:

http_req_duration..............: avg=2.5s p(95)=5.2s

Рішення:

  1. Збудувати в trybie випуску: dotnet run -c Release
  2. Впевнитись, що кэшування працює
  3. Проверка диска I/O M SK1повільне читання файлу)
  4. Профиль з Dotnet-trace:
dotnet-trace collect -p $(pgrep -f MinimalBlog) --format speedscope

Проблема 4: Похибка пам 'яті в тестах протікання

Проблема: Вживання пам 'яті постійно зростає

Рішення:

  1. Навігатор з:
dotnet-counters monitor --counters System.Runtime[gc-heap-size,gc-committed,gc-allocated]
  1. Збирати сміття для пам 'яті:
dotnet-dump collect -p $(pgrep -f MinimalBlog)
dotnet-dump analyze memory.dump
  1. Проверка для:
    • Кэш не закінчується
    • Файл не закривається
    • Рухівники подій не відмовляються від підпису

Реальний-World ExampleM SK1 Тестування перед релізом

Ось повний тест робочого потоку перед випуском MinimalBlog

#!/bin/bash
# test-release.sh

set -e

echo "Building: Building MinimalBlog in Release mode..."
dotnet build -c Release Mostlylucid.MinimalBlog/Mostlylucid.MinimalBlog.csproj

echo "Starting: Starting MinimalBlog Demo..."
dotnet run -c Release --project Mostlylucid.MinimalBlog.Demo &
APP_PID=$!

# Wait for app to start
echo "Waiting: Waiting for app to start..."
timeout 30 bash -c 'until curl -s http://localhost:5000 > /dev/null; do sleep 1; done'

echo "- App started successfully"

# Run test suite
echo "Running: Running smoke tests..."
k6 run k6-tests/smoke-test.js

echo "Running: Running cache validation..."
k6 run k6-tests/cache-test.js

echo "Running: Running load tests..."
k6 run k6-tests/load-test.js

echo "Running: Running stress tests..."
k6 run k6-tests/stress-test.js

echo "Running: Running spike tests..."
k6 run k6-tests/spike-test.js

echo "Generating: Generating combined report..."
# Process and combine results

echo "Stopping: Stopping app..."
kill $APP_PID

echo "- All tests completed successfully!"

Прокрутить його:

chmod +x test-release.sh
./test-release.sh

Профіляція з DotTrace і dotMemory

k6 каже вам що це повільне, але файлери кажуть вам чому. Об 'єднання kM SK1 тестування на завантаження з профайлерами JetBrains (dotTrace для продуктивності МSK3 dotMemory для пам' яті ) дозволяє вам визначити певні вузьки у MinimalBlog коді MSC5

Навіщо завантажувати профіль?

Профіляція без навантаження часто занехтує реальними проблемами-світні проблемиM SK1

  • Холодний старт проти теплого 缓ку: Різні шляхи коду
  • Конкурентний доступ: Конкуренція з блокуваннямM SK1 умови гонки
  • Натиск пам 'яті: Ситуація GC під навантаженням
  • Вичерпання ресурсів: Схема для підключення,

k6 створює реальне obciążenie, тоді як аналітики фіксують те, що відбувається всередині вашої додатки

Установка: Установлення інструментів JetBrains

Опція 1: JetBrains dotTraceM SK1dotMemory (Commercial)

завантажити з JetBrains:

# Linux/Mac
wget https://download.jetbrains.com/resharper/dotUltimate.2024.3/JetBrains.dotTrace.GlobalTools.2024.3.nupkg

# Install as global tool
dotnet tool install --global JetBrains.dotTrace.GlobalTools
dotnet tool install --global JetBrains.dotMemory.Console

Вибір: 2: точка-навігаціяM SK1відшукання МSK2Свободний, збудованийМСК4вMСК5

dotnet tool install --global dotnet-trace
dotnet tool install --global dotnet-counters
dotnet tool install --global dotnet-dump

Для цього інструкції ми покажемо обидві підходи:

Профіляція робочого процесу

flowchart LR
    A[Start App] --> B[Baseline<br/>Snapshot]
    B --> C[Start Profiler]
    C --> D[Run k6 Load Test]
    D --> E[Capture Metrics]
    E --> F[Stop Profiler]
    F --> G[Final Snapshot]
    G --> H{Analyze Results}
    H --> I[Identify<br/>Hotspots]
    I --> J[Optimize Code]
    J --> K[Re-test with k6]
    K --> L{Better?}
    L -->|Yes| M[Document & Deploy]
    L -->|No| I

    style M stroke:#51cf66
    style I stroke:#FFD700

Шаг 1: Базова лінія без навантаження Шаг 2: Профиль під навантаженням kM SK1 Шаг 3: Порівняти і визначити вузли Шаг 4: виправити і переробити МSK1тест

Профіферування ефективності за допомогою dotTrace

Scenario: Поява повільного аналізу позначок

1. Зачати MinimalBlog з прикріпленим профілингом

cd Mostlylucid.MinimalBlog.Demo

# Using dotTrace
dottrace attach <PID> --save-to=profile-baseline.dtt --timeout=60s

# Or build and run with profiling
dotnet build -c Release
dotnet run -c Release &
APP_PID=$!

# Attach profiler
dottrace attach $APP_PID --save-to=profile-load.dtt --timeout=120s

2. В іншому терминалі МSK1 запустіть k МSK2 тест навантаження :

# This generates load while profiler captures data
k6 run --duration 60s --vus 20 k6-tests/load-test.js

3. Проаналізувати профільM SK1

# Convert to speedscope format for web viewing
dottrace report profile-load.dtt --output=report.html

Що шукати в звіті:

  • Горячі шляхи: Методи, які споживають більшість часу CPU
  • Дерево дзвінків: Де витрачається час в ієрархії дзвінків
  • Самотній час: Час в методі, за виключенням дзвінків до інших методів

Ось приклади результатів в MinimalBlog:

Method                                    Total Time    Self Time    Calls
-----------------------------------------------------------------------
 MarkdownBlogService.GetAllPosts()         450ms        5ms          100
  ├─ LoadAllPosts()                       420ms        10ms         10
  │   ├─ ParseFile()                      400ms        20ms         100
  │   │   ├─ Markdown.Parse()             250ms        250ms        100   HOTSPOT
  │   │   └─ Regex.Match() (categories)   80ms         80ms         100   HOTSPOT
  │   └─ File.ReadAllText()               10ms         10ms         100
  └─ cache.GetOrCreate()                  25ms         25ms         90

Це показує:

  • Markdown.Parse() є #1 вузол МSK1м суто МSK2
  • Регексний співпад - #2 (80ms в ціломуM SK2
  • Найчастіше в перший раз 10 виклики ( залишає таємницю, а потім залишається в таємниці

Використовуючи комп 'ютерні мережі

# Start tracing
dotnet-trace collect -p $APP_PID --format speedscope -o trace.json &
TRACE_PID=$!

# Run k6 test
k6 run --duration 30s --vus 10 k6-tests/load-test.js

# Stop tracing
kill -SIGINT $TRACE_PID

# View in browser
# Upload trace.json to https://www.speedscope.app/

Візуалізація швидкого спектру:

  • Граф Flame показує стопки викликів
  • Часовий порядок зображає виконання протягом часу
  • Links heavy view висвітлює повільні операції

Спеціалізація пам 'яті за допомогою DotMemory

сценарій: виявлення витіку пам 'яті в кэші

1. Зайвіть MinimalBlog і прикріпити до нього профайлер пам 'ятіM SK1

cd Mostlylucid.MinimalBlog.Demo
dotnet run -c Release &
APP_PID=$!

# Take initial snapshot
dotmemory get-snapshot $APP_PID --save-to=snapshot-start.dmw

2. Пройти тест на завантаження

# Run for 5 minutes with constant load
k6 run --duration 5m --vus 20 k6-tests/load-test.js

3. Зйомка знімків під час та після тесту

# During load (after 2 minutes)
sleep 120
dotmemory get-snapshot $APP_PID --save-to=snapshot-load.dmw

# After load (cool down)
# Wait for k6 to finish, then wait 2 more minutes
sleep 120
dotmemory get-snapshot $APP_PID --save-to=snapshot-after.dmw

4. Проаналізувати ріст пам 'яті

# Compare snapshots
dotmemory compare snapshot-start.dmw snapshot-after.dmw --save-to=comparison.html

Що шукати:

  • Зростаючих колекцій: СпискиM SK1 Словари, які ніколи не зменшуються
  • Керівники подій: Незареєстровані події, що мають відмітки
  • bloat Cache: Cache росте вище очікуваного розміру
  • Дозволення стрічок: Надмірна конкатенція струн

Наведу приклади результатів:

Object Type                      Start    Load     After    Growth
-------------------------------------------------------------------
System.String                    5 MB     45 MB    15 MB    +10 MB
BlogPost[]                       2 MB     2 MB     2 MB     0 MB    PASS
MarkdownDocument                 0 MB     8 MB     0 MB     0 MB    - (GC'd)
Dictionary<string, BlogPost>     1 MB     1 MB     1 MB     0 MB    PASS

Це показує:

  • Стрини зростали до 10 MB ( потенційного витіку струн або проблеми з кэшомM SK2
  • Cache BlogPost стабільний (goodM SK1
  • Маркдаудокумент очищен GC (goodM SK1

Використовуючи комп 'ютерні мережі

# Capture memory dump during load
dotnet-dump collect -p $APP_PID -o dump-load.dmp

# After test
dotnet-dump collect -p $APP_PID -o dump-after.dmp

# Analyze dump
dotnet-dump analyze dump-load.dmp

> dumpheap -stat
> dumpheap -mt <MethodTable> -min 1000
> gcroot <address>

Комбінований 6 МSK1 Скрип для обробки profili

Тут' - це повний скрипт, що запускає kM SK1 під час створення профиля:

Файл: profile-under-load.sh

#!/bin/bash
set -e

echo "Profiling: Profiling MinimalBlog under k6 load"

# Configuration
DURATION="120s"
VUS="20"
OUTPUT_DIR="profiling-results"

mkdir -p $OUTPUT_DIR

# Build and start app
echo "Building: Building MinimalBlog..."
cd Mostlylucid.MinimalBlog.Demo
dotnet build -c Release > /dev/null

echo "Starting: Starting MinimalBlog..."
dotnet run -c Release > $OUTPUT_DIR/app.log 2>&1 &
APP_PID=$!
echo $APP_PID > $OUTPUT_DIR/app.pid

# Wait for startup
timeout 60 bash -c "until curl -sf http://localhost:5000 > /dev/null; do sleep 2; done"
echo "- App started (PID: $APP_PID)"

# Baseline metrics
echo "Generating: Collecting baseline metrics..."
dotnet-counters collect -p $APP_PID --format json -o $OUTPUT_DIR/baseline-metrics.json &
COUNTER_PID=$!
sleep 10
kill -SIGINT $COUNTER_PID

# Take initial memory snapshot
echo "Snapshot: Initial memory snapshot..."
if command -v dotmemory &> /dev/null; then
    dotmemory get-snapshot $APP_PID --save-to=$OUTPUT_DIR/snapshot-start.dmw
else
    dotnet-dump collect -p $APP_PID -o $OUTPUT_DIR/dump-start.dmp
fi

# Start performance profiling
echo "Starting: Starting performance profiler..."
if command -v dottrace &> /dev/null; then
    dottrace attach $APP_PID --save-to=$OUTPUT_DIR/performance-profile.dtt --timeout=150s &
    PROFILER_PID=$!
else
    dotnet-trace collect -p $APP_PID --format speedscope -o $OUTPUT_DIR/trace.json &
    PROFILER_PID=$!
fi

sleep 5

# Run k6 load test
echo "Running: Running k6 load test ($DURATION, $VUS VUs)..."
cd ..
k6 run --duration $DURATION --vus $VUS \
    --out json=$OUTPUT_DIR/k6-results.json \
    k6-tests/load-test.js | tee $OUTPUT_DIR/k6-output.txt

echo "- k6 test completed"

# Wait for profiler to finish
wait $PROFILER_PID
echo "- Performance profile captured"

# Take final memory snapshot
echo "Snapshot: Final memory snapshot..."
if command -v dotmemory &> /dev/null; then
    dotmemory get-snapshot $APP_PID --save-to=$OUTPUT_DIR/snapshot-end.dmw

    echo "Comparing: Comparing memory snapshots..."
    dotmemory compare $OUTPUT_DIR/snapshot-start.dmw $OUTPUT_DIR/snapshot-end.dmw \
        --save-to=$OUTPUT_DIR/memory-comparison.html
else
    dotnet-dump collect -p $APP_PID -o $OUTPUT_DIR/dump-end.dmp
fi

# Stop app
echo "Stopping: Stopping MinimalBlog..."
kill $APP_PID

# Generate reports
echo "Generating: Generating reports..."

if command -v dottrace &> /dev/null; then
    dottrace report $OUTPUT_DIR/performance-profile.dtt \
        --output=$OUTPUT_DIR/performance-report.html
fi

# Summary
echo ""
echo "========================================="
echo "- Profiling Complete!"
echo "========================================="
echo ""
echo "Results in: $OUTPUT_DIR/"
echo ""
echo "Files generated:"
ls -lh $OUTPUT_DIR/
echo ""
echo "Generating: View results:"
echo "  - k6 output: cat $OUTPUT_DIR/k6-output.txt"
echo "  - Performance profile: open $OUTPUT_DIR/performance-report.html"
echo "  - Memory comparison: open $OUTPUT_DIR/memory-comparison.html"
echo "  - Speedscope trace: https://www.speedscope.app/ (upload trace.json)"
echo ""

Прокрутить його:

chmod +x profile-under-load.sh
./profile-under-load.sh

Найкращі практики: kM SK1 + Профіляція

  1. Повсякчас відображатися під реалістичним навантаженням

    • Використовуйте k6 для симуляції моделей потоку виробництва
    • Profile idle apps не розповідають вам нічого про реальну ефективність
  2. Візьміть декілька знімків

    • Перед завантаженням (початкова лініяM SK1
    • Під час навантаження (активнийM SK1
    • Після завантаження ( перевірити прибиранняM SK1
  3. Сфокусуватися на гарячих маршрутах спочатку

    • Спочатку виправити найбільші перешкоди
    • 80/20 правилоM SK1 20% коду займає МSK3 часу
  4. До та після

    • Знову повторювати тести після оптимізації
    • Перевірити покращення за допомогою профайлера
  5. Дивіться на регресії

    • Залишити базові профілі в репо
    • Порівняйте профілі в CI/CD
  6. Збудування випуску profili

    • Збудування розладів мають різні характеристики
    • Повсякчас -c Release для створення профилів

Підсумок інструментів

Оборудование МSK1 Задача МSK2 Koszt Найкраще для M
k6 Тестування завантаження МSK1 Бесплатно МSK2 Визначати, що повільне
Послідування точками Дослідження ефективності МSK1 Оплачуваний МSK2 З 'ясування, чому це повільне
Дотка пам 'яті Профіляція пам 'яті
dotnet-трак Профіляція продуктивності МSK1 Вільний Початкова модель процесора МSK3
Дотнет-рахунки Реальний МSK1Метриці часу МSK2 Вільний Живе спостереження мSK4
dotnet-dump Думки пам 'яті МSK1 Бесплатно МSK2 Позволення -аналіз смерті MSК4
PerfView Заawansowane опрацьовування МSK1 Вільно Deep Windows опрацьовують МSK3

Conclusion: Побудувати довіру шляхом тестування

Завантаження тесту за допомогою k6 дає вам впевненість, що MinimalBlog може справлятися з реальним - світовою трафіком МSK2 До кінця цих двох МСК3 інструкції для частини МСК4 вам треба бути в змозі

  • Установіть k6 на будь-якій платформі.
  • Написати і запустити різні види тестів на ефективність
  • Впевнитись, що поведінкаキャッシュування працює так, як очікувалося
  • Знайти перешкоди ефективності перед тим, як вони досягнуть рівня виробництва
  • Інтегрувати тести на завантаження в труби CI/CD
  • Прослідкувати та інтерпретувати метрики k6

Key Takeaways

  1. Почнемо з тестів на куріння - Перевірити базову функцію перед глибшим тестуванням
  2. Випробувати Caching явно - MinimalBlog ' результати залежать від нього
  3. Використовувати реалістичні дані - Empty files don 't represent real usage
  4. Спостереження ресурсів системи - Процесор МSK1 пам 'ять МSK2 GC під час тестування
  5. Встановити значні шкали - Враховуючи реальні потребиM SK1 не підозрює
  6. Автоматізувати в CI/CD - На ранній стадії регресії
  7. Випробувати різні сценарії - Веб-сайтМSK1 записиМСК2 категоріїМ СК3 помилки

Що ми дізналися про MinimalBlog

Через тестування k6 , ми можемо перевірити вимоги MinimalBlogM SK2s:

  • НайшвидшеМSK0 p(95) M SK2 \300м з гарячим кэшом
  • Мощність: Невелике використання пам 'яті , мінімальний тиск GC
  • Скалабельна: Ручки 100+ для одночасних користувачів на скромному апараті
  • Надежна: < МSK2 частота помилок під нормальною навантаженням
  • Cache-ефективний: МSK1x швидші відповіді з теплом кэшом

Наступні кроки

Тепер ви знаєте, як перевірити ASP.NET з k6:

  1. Створити базовий профіль ефективності для вашого налаштування
  2. Установіть автоматизоване тестування в вашій трубці CI/CD
  3. Пройвіть тести на запилення перед великими релізами
  4. Наблюдайте за показниками виробництва і порівняйте їх з результатами тестування
  5. Ітерувати: тест M SK1 оптимізувати -> тест знову

Пам 'ятайте: тестування ефективності - це не одна-єдина. Коли ви додаєте контент, МSK1 змінюєте код, , або змінюєтесь провайдерами хостингу, |, | перезапускаєте |МSK4 | запускайте ці тести, щоб гарантувати, що ваша програма залишається швидкою і надійною | МSK5 |

Ресурс

k6 Документація

Акція GitHub

Програмні інструменти

Наслідування & Візуалізація

MinimalBlog

Досконалість ASP.NET

Щасливе тестування!

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.