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

<!--category-- Testing, Performance, k6, ASP.NET -->
<datetime class="hidden">2025-12-02T15:00</datetime>

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

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

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

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

[TOC]

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

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

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

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

```bash
cd Mostlylucid.MinimalBlog.Demo
dotnet run
```

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

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

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

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

```bash
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 для тестування:**

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

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

```bash
# 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. Подготуйте дані тесту

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

```bash
# 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

<!-- category -- Testing, Performance -->
<datetime class="hidden">2025-12-01T12:00</datetime>

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. Створити каталог тестових сценаріїв

```bash
mkdir k6-tests
cd k6-tests
```

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

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

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

**Файл: `smoke-test.js`**

```javascript
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'),
  });
}
```

**Пройти тест:**

```bash
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`**

```javascript
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']}`);
  });
}
```

**Пройти тест:**

```bash
k6 run cache-test.js
```

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

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

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

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

**Файл: `load-test.js`**

```javascript
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
}
```

**Пройти тест:**

```bash
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`**

```javascript
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 }),
  };
}
```

**Пройти тест:**

```bash
k6 run stress-test.js
```

Дивіться на:

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

## Тест 5: Тест Spike

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

**Файл: `spike-test.js`**

```javascript
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,
  });
}
```

**Пройти тест:**

```bash
k6 run spike-test.js
```

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

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

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

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

**Файл: `soak-test.js`**

```javascript
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);
}
```

**Пройти тест:**

```bash
k6 run soak-test.js
```

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

```bash
# 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`**

```javascript
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),
  };
}
```

**Пройти тест:**

```bash
k6 run user-journey-test.js
```

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

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

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

**Файл: `metaweblog-test.js`**

```javascript
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'),
  });
}
```

**Пройти тест:**

```bash
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`:

```yaml
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
          <!-- category -- Testing, Performance -->
          <datetime class="hidden">2025-12-01T12:00</datetime>

          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

```mermaid
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 коментарі:

```yaml
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
          <!-- category -- Testing -->
          <datetime class="hidden">2025-12-01T12:00</datetime>
          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` для виявлення регресії ефективності:

```yaml
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 "<!-- category -- Test -->" >> TestMarkdown/test-$i.md
            echo '<datetime class="hidden">2025-12-01T12:00</datetime>' >> 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%**
- Захищає повільне поєднання коду

```mermaid
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. **Використовуйте відповідних меж**
   
   ```javascript
   // 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. **Відлежність відキャッシュа**
   
   ```yaml
   - name: Cache .NET packages
     uses: actions/cache@v4
     with:
       path: ~/.nuget/packages
       key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj') }}
   ```

4. **Збирати журнали для невдачливих тестів**
   
   ```yaml
   - name: Upload App Logs
     if: failure()
     uses: actions/upload-artifact@v4
     with:
       name: app-logs
       path: Mostlylucid.MinimalBlog.Demo/app.log
   ```

5. **Використовуйте Environment-конкретні пороги**
   
   ```javascript
   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** для моніторингу:

```yaml
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

```bash
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 окремо від інших сервісів:

```bash
# 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

```javascript
// 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

```bash
# 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. Установити реальні пороги

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

```javascript
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. Випробовуємо різні сценарії

```javascript
// 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"
```

**Рішення:**

```bash
# 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:

```bash
dotnet-trace collect -p $(pgrep -f MinimalBlog) --format speedscope
```

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

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

**Рішення:**

1. Навігатор з:

```bash
dotnet-counters monitor --counters System.Runtime[gc-heap-size,gc-committed,gc-allocated]
```

2. Збирати сміття для пам 'яті:

```bash
dotnet-dump collect -p $(pgrep -f MinimalBlog)
dotnet-dump analyze memory.dump
```

3. Проверка для:
   - Кэш не закінчується
   - Файл не закривається
   - Рухівники подій не відмовляються від підпису

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

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

```bash
#!/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!"
```

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

```bash
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](https://www.jetbrains.com/profiler/):

```bash
# 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**

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

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

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

```mermaid
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 з прикріпленим профілингом**

```bash
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 тест навантаження :**

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

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

```bash
# 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 виклики ( залишає таємницю, а потім залишається в таємниці

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

```bash
# 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**

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

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

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

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

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

```bash
# 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. Проаналізувати ріст пам 'яті**

```bash
# 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

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

```bash
# 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`**

```bash
#!/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 ""
```

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

```bash
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 Документація

- [офіційні доки k6](https://k6.io/docs/) - Завершити kM SK1 документацію
- [k6 JavaScript API](https://k6.io/docs/javascript-api/) - Всі доступні API kM SK1
- [k6 приклади](https://github.com/grafana/k6-learn) - Example test scripts
- [rozszerzenia k6](https://k6.io/docs/extensions/) - Поширити функцію kM SK1
- [k6 метрики](https://k6.io/docs/using-k6/metrics/) - Порозуміння метрики
- [k6 шкали](https://k6.io/docs/using-k6/thresholds/) - Постановка
- [k6 сценарії](https://k6.io/docs/using-k6/scenarios/) - Заawansовані сценарії тесту

### Акція GitHub

- [Документи для дій GitHub](https://docs.github.com/en/actions) - Полна документація про дії
- [Синтаксис робочого потоку](https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions) - YAML
- [Використовуючи артефакти](https://docs.github.com/en/actions/guides/storing-workflow-data-as-artifacts) - Результати тесту в магазині
- [Налагодження дій](https://github.com/grafana/setup-k6-action) - kM SK1 дії налаштування

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

- [dotnet-трак](https://learn.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-trace) - Профіляція ефективності
- [Дотнет-рахунки](https://learn.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-counters) МSK0 Реальний-часові метрики
- [dotnet-dump](https://learn.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-dump) - Пам 'ять
- [JetBrains dotTrace](https://www.jetbrains.com/profiler/) - Коммерційний profiler
- [JetBrains dotMemory](https://www.jetbrains.com/dotmemory/) - Профильер пам 'яті
- [Швидкісний спектр](https://www.speedscope.app/) - Принтер графіку плавання

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

- [k6 Хмара](https://k6.io/cloud/) - Хмара -на основі kM SK2 тестування
- [k6 Репортер](https://github.com/benc-uk/k6-reporter) - HTML звіти
- [Графана k6 Панель](https://grafana.com/grafana/dashboards/18030) - kM SK1 панель приладів
- [Прометеус](https://prometheus.io/docs/introduction/overview/) - Коллекция вимірів
- [Графана](https://grafana.com/docs/) - візуалізація метрики

### MinimalBlog

- [MinimalBlog - вступ](/blog/minimalblog-introduction) - Чому MinimalBlog існує
- [Початковий код](https://github.com/scottgal/mostlylucidweb/tree/main/Mostlylucid.MinimalBlog) - Полне джерело
- [Пакет NuGet](https://www.nuget.org/packages/Mostlylucid.MinimalBlog) - Установити за допомогою NuGet
- [Демо-проект](https://github.com/scottgal/mostlylucidweb/tree/main/Mostlylucid.MinimalBlog.Demo) - Рабочий приклад

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

- [ASP.NET Core Performance](https://learn.microsoft.com/en-us/aspnet/core/performance/performance-best-practices) - Найкращі практики
- [Caching в ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/performance/caching/response) - Caching відповідей
- [Менеджмент пам 'яті](https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/) МSK0 .NET GC
- [Diagnostic tools](https://learn.microsoft.com/en-us/dotnet/core/diagnostics/) - МSK1NET діагностика

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