Завантаження тестування ASP.NET Core Applications з k6: Практичною Implementation
Тепер, коли ви розумієте основи 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 дає хибні результати:
- Жодної оптимізації JIT: Компілятор зберігає структуру коду для виправ, а не оптимізує швидкість
- Додаткові інструменти: Побудові деbugу включають код для розбіжних точок , змінна інспектація M SK2 та сліди стека
- Немає вказівок: Методи не запрограмованіM SK1 не вбудовані , додаючи накладні витрати на телефонний дзвінок, які з 'явились в процесі виробництва
- Виведення твердження:
Debug.Assert()вказівки виконувати, додаючи перевірки, що виробництво не буде - Різні моделі пам 'яті: При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
Цей тест покаже вам:
- Перше очікування ( коли кэш холоднийM SK1
- Наступні строки запиту (горячий таємникM SK1
- Перевірка заголовків 缓шів
Тест 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
Почнемо швидше, Вчасно
- Спершу проводимо тести на куріння (30sM SK1
- Пройти повні тести, якщо кур проходить
- Не вдалось швидко заpisać хвилини CI
Використовуйте відповідних меж
// 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'] }Відлежність відキャッシュа
- name: Cache .NET packages uses: actions/cache@v4 with: path: ~/.nuget/packages key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj') }}Збирати журнали для невдачливих тестів
- name: Upload App Logs if: failure() uses: actions/upload-artifact@v4 with: name: app-logs path: Mostlylucid.MinimalBlog.Demo/app.logВикористовуйте 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 Панель в графані
- Доступ до графани в
http://localhost:3000 - Додайте вихідний код Prometheus
- В voer k6 панель управления M SK1ID: 18030)
Перевод k6 Метрії
Ключевые метрики для розуміння:
Метріка часу реагування
- http_reqM SK1тривалість: Весь час, проведений за запитом
avg: Середній час реагуванняmin/max: Найшвидший / найнижчий відгукmedМSK0 Середній (50десятий відсоток МSK2p(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%)
Рішення:
- Проверяйте журнали застосування за помилками
- Перевірити, чи існують дані тесту (markdown filesM SK1
- Скорінити кількість VU (можливо надмірне навантаженняM SK1
- Збільшити czas на підйомку
Публикація 3: Повільні часи реагування
Проблема:
http_req_duration..............: avg=2.5s p(95)=5.2s
Рішення:
- Збудувати в trybie випуску:
dotnet run -c Release - Впевнитись, що кэшування працює
- Проверка диска I/O M SK1повільне читання файлу)
- Профиль з Dotnet-trace:
dotnet-trace collect -p $(pgrep -f MinimalBlog) --format speedscope
Проблема 4: Похибка пам 'яті в тестах протікання
Проблема: Вживання пам 'яті постійно зростає
Рішення:
- Навігатор з:
dotnet-counters monitor --counters System.Runtime[gc-heap-size,gc-committed,gc-allocated]
- Збирати сміття для пам 'яті:
dotnet-dump collect -p $(pgrep -f MinimalBlog)
dotnet-dump analyze memory.dump
- Проверка для:
- Кэш не закінчується
- Файл не закривається
- Рухівники подій не відмовляються від підпису
Реальний-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 + Профіляція
Повсякчас відображатися під реалістичним навантаженням
- Використовуйте k6 для симуляції моделей потоку виробництва
- Profile idle apps не розповідають вам нічого про реальну ефективність
Візьміть декілька знімків
- Перед завантаженням (початкова лініяM SK1
- Під час навантаження (активнийM SK1
- Після завантаження ( перевірити прибиранняM SK1
Сфокусуватися на гарячих маршрутах спочатку
- Спочатку виправити найбільші перешкоди
- 80/20 правилоM SK1 20% коду займає МSK3 часу
До та після
- Знову повторювати тести після оптимізації
- Перевірити покращення за допомогою профайлера
Дивіться на регресії
- Залишити базові профілі в репо
- Порівняйте профілі в CI/CD
Збудування випуску 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
- Почнемо з тестів на куріння - Перевірити базову функцію перед глибшим тестуванням
- Випробувати Caching явно - MinimalBlog ' результати залежать від нього
- Використовувати реалістичні дані - Empty files don 't represent real usage
- Спостереження ресурсів системи - Процесор МSK1 пам 'ять МSK2 GC під час тестування
- Встановити значні шкали - Враховуючи реальні потребиM SK1 не підозрює
- Автоматізувати в CI/CD - На ранній стадії регресії
- Випробувати різні сценарії - Веб-сайтМSK1 записиМСК2 категоріїМ СК3 помилки
Що ми дізналися про MinimalBlog
Через тестування k6 , ми можемо перевірити вимоги MinimalBlogM SK2s:
- НайшвидшеМSK0 p(95) M SK2 \300м з гарячим кэшом
- Мощність: Невелике використання пам 'яті , мінімальний тиск GC
- Скалабельна: Ручки 100+ для одночасних користувачів на скромному апараті
- Надежна: < МSK2 частота помилок під нормальною навантаженням
- Cache-ефективний: МSK1x швидші відповіді з теплом кэшом
Наступні кроки
Тепер ви знаєте, як перевірити ASP.NET з k6:
- Створити базовий профіль ефективності для вашого налаштування
- Установіть автоматизоване тестування в вашій трубці CI/CD
- Пройвіть тести на запилення перед великими релізами
- Наблюдайте за показниками виробництва і порівняйте їх з результатами тестування
- Ітерувати: тест M SK1 оптимізувати -> тест знову
Пам 'ятайте: тестування ефективності - це не одна-єдина. Коли ви додаєте контент, МSK1 змінюєте код, , або змінюєтесь провайдерами хостингу, |, | перезапускаєте |МSK4 | запускайте ці тести, щоб гарантувати, що ваша програма залишається швидкою і надійною | МSK5 |
Ресурс
k6 Документація
- офіційні доки k6 - Завершити kM SK1 документацію
- k6 JavaScript API - Всі доступні API kM SK1
- k6 приклади - Example test scripts
- rozszerzenia k6 - Поширити функцію kM SK1
- k6 метрики - Порозуміння метрики
- k6 шкали - Постановка
- k6 сценарії - Заawansовані сценарії тесту
Акція GitHub
- Документи для дій GitHub - Полна документація про дії
- Синтаксис робочого потоку - YAML
- Використовуючи артефакти - Результати тесту в магазині
- Налагодження дій - kM SK1 дії налаштування
Програмні інструменти
- dotnet-трак - Профіляція ефективності
- Дотнет-рахунки МSK0 Реальний-часові метрики
- dotnet-dump - Пам 'ять
- JetBrains dotTrace - Коммерційний profiler
- JetBrains dotMemory - Профильер пам 'яті
- Швидкісний спектр - Принтер графіку плавання
Наслідування & Візуалізація
- k6 Хмара - Хмара -на основі kM SK2 тестування
- k6 Репортер - HTML звіти
- Графана k6 Панель - kM SK1 панель приладів
- Прометеус - Коллекция вимірів
- Графана - візуалізація метрики
MinimalBlog
- MinimalBlog - вступ - Чому MinimalBlog існує
- Початковий код - Полне джерело
- Пакет NuGet - Установити за допомогою NuGet
- Демо-проект - Рабочий приклад
Досконалість ASP.NET
- ASP.NET Core Performance - Найкращі практики
- Caching в ASP.NET Core - Caching відповідей
- Менеджмент пам 'яті МSK0 .NET GC
- Diagnostic tools - МSK1NET діагностика
Щасливе тестування!