Финальный проект: внедрите k6 в свой проект

**Задание:** Составьте список критических API endpoints вашего приложения
 
Критерии критичности:
 
- [ ] Endpoint используется в 80% пользовательских сценариев
- [ ] Деградация этого endpoint влияет на revenue
- [ ] Endpoint участвует в критическом business flow (регистрация, оплата, авторизация)
 
**Мой список критических endpoints:**
 
1. POST /auth/login — авторизация
2. GET /api/products — каталог товаров
3. POST /api/cart/add — добавление в корзину
4. POST /api/orders/create — создание заказа
5. ...

// tests/smoke.js
import http from "k6/http";
import { check, sleep } from "k6";
 
export const options = {
  scenarios: {
    smoke: {
      executor: "shared-iterations",
      iterations: 10,
      vus: 2,
      maxDuration: "2m",
    },
  },
  thresholds: {
    http_req_failed: ["rate<0.05"], // < 5% ошибок
    http_req_duration: ["p(95)<1000"], // p95 < 1s (временный, уточните позже)
    checks: ["rate>0.95"], // > 95% проверок прошли
  },
};
 
const BASE_URL = __ENV.BASE_URL || "https://staging.yourapp.com";
 
export default function () {
  // Замените на ваши критические endpoints
 
  // 1. Health check
  let res = http.get(`${BASE_URL}/health`);
  check(res, {
    "health check is 200": (r) => r.status === 200,
  });
 
  // 2. Критический endpoint 1
  res = http.get(`${BASE_URL}/api/products?limit=10`);
  check(res, {
    "products list is 200": (r) => r.status === 200,
    "has products": (r) => {
      const body = JSON.parse(r.body || "{}");
      return body.products && body.products.length > 0;
    },
  });
 
  // 3. Критический endpoint 2 (с авторизацией)
  const token = __ENV.TEST_TOKEN; // Передайте через env
  res = http.post(
    `${BASE_URL}/api/cart/add`,
    JSON.stringify({ productId: "test-1", quantity: 1 }),
    {
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${token}`,
      },
    }
  );
  check(res, {
    "cart add is 200": (r) => r.status === 200 || r.status === 201,
  });
 
  sleep(1);
}

# .github/workflows/smoke-test.yml
name: Smoke Test
 
on:
  pull_request:
    branches: [main, develop]
  push:
    branches: [main]
 
jobs:
  smoke-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Run k6 smoke test
        uses: grafana/k6-action@v0.3.1
        with:
          filename: tests/smoke.js
        env:
          BASE_URL: ${{ secrets.STAGING_URL }}
          TEST_TOKEN: ${{ secrets.TEST_TOKEN }}
 
      - name: Upload results
        if: always()
        uses: actions/upload-artifact@v3
        with:
          name: k6-results
          path: summary.json

# .gitlab-ci.yml
smoke-test:
  stage: test
  image: grafana/k6:latest
  script:
    - k6 run tests/smoke.js --summary-export summary.json
  artifacts:
    when: always
    paths:
      - summary.json
    expire_in: 30 days
  variables:
    BASE_URL: $STAGING_URL
    TEST_TOKEN: $TEST_TOKEN
  only:
    - merge_requests
    - main

// tests/load-checkout.js
import http from "k6/http";
import { check, sleep } from "k6";
import { SharedArray } from "k6/data";
 
// Загружаем тестовые данные
const products = new SharedArray("products", function () {
  return JSON.parse(open("./fixtures/products.json"));
});
 
export const options = {
  scenarios: {
    load_test: {
      executor: "ramping-vus",
      startVUs: 0,
      stages: [
        { duration: "2m", target: 10 }, // Warmup
        { duration: "5m", target: 50 }, // Ramp-up
        { duration: "10m", target: 50 }, // Plateau (основной тест)
        { duration: "2m", target: 0 }, // Ramp-down
      ],
      gracefulRampDown: "30s",
    },
  },
  thresholds: {
    // Уточните на основе ваших SLO
    "http_req_duration{flow:checkout}": ["p(95)<800", "p(99)<1500"],
    "http_req_failed{flow:checkout}": ["rate<0.01"],
    "checks{flow:checkout}": ["rate>0.97"],
  },
};
 
const BASE_URL = __ENV.BASE_URL || "https://staging.yourapp.com";
 
export default function () {
  const product = products[Math.floor(Math.random() * products.length)];
 
  // 1. Browse products
  let res = http.get(`${BASE_URL}/api/products`, {
    tags: { flow: "browse" },
  });
  check(res, { "browse OK": (r) => r.status === 200 });
  sleep(2); // Think time
 
  // 2. View product details
  res = http.get(`${BASE_URL}/api/products/${product.id}`, {
    tags: { flow: "browse" },
  });
  check(res, { "product details OK": (r) => r.status === 200 });
  sleep(1);
 
  // 3. Add to cart
  res = http.post(
    `${BASE_URL}/api/cart/add`,
    JSON.stringify({ productId: product.id, quantity: 1 }),
    {
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${__ENV.TEST_TOKEN}`,
      },
      tags: { flow: "checkout" },
    }
  );
  check(res, { "add to cart OK": (r) => r.status === 200 || r.status === 201 });
  sleep(2);
 
  // 4. Checkout
  res = http.post(
    `${BASE_URL}/api/orders/create`,
    JSON.stringify({
      paymentMethod: "test",
      shippingAddress: "Test Street 1",
    }),
    {
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${__ENV.TEST_TOKEN}`,
      },
      tags: { flow: "checkout" },
    }
  );
  check(res, {
    "checkout OK": (r) => r.status === 200 || r.status === 201,
    "has orderId": (r) => {
      const body = JSON.parse(r.body || "{}");
      return body.orderId !== undefined;
    },
  });
 
  sleep(5); // Think time after purchase
}

# 1. Запустите тест на чистом стенде
k6 run tests/load-checkout.js --summary-export baseline.json
 
# 2. Сохраните baseline в Git
git add baseline.json
git commit -m "feat: add load test baseline for checkout flow"
git push
 
# 3. Документируйте условия baseline
echo "## Baseline для checkout flow
 
**Дата:** $(date)
**Версия:** v1.2.3
**Условия:**
- Стенд: staging (4 CPU, 8GB RAM)
- БД: PostgreSQL 15, пустая (только fixtures)
- Сценарий: 50 VU, 10 минут plateau
 
**Результаты:**
- p95: 450ms
- p99: 850ms
- Error rate: 0.2%
- Checks: 98.5%
" > baseline-checkout.md

// scripts/compare-baseline.js
import fs from "fs";
 
const baseline = JSON.parse(fs.readFileSync("baseline.json", "utf8"));
const current = JSON.parse(fs.readFileSync("summary.json", "utf8"));
 
const metrics = ["http_req_duration", "http_req_failed"];
let hasRegression = false;
 
for (const metric of metrics) {
  const baseVal = baseline.metrics[metric].values["p(95)"];
  const currVal = current.metrics[metric].values["p(95)"];
  const diff = ((currVal - baseVal) / baseVal) * 100;
 
  console.log(`${metric} p95: ${currVal}ms (${diff.toFixed(1)}% vs baseline)`);
 
  if (Math.abs(diff) > 10) {
    console.error(`⚠️  Regression detected: ${diff.toFixed(1)}%`);
    hasRegression = true;
  }
}
 
process.exit(hasRegression ? 1 : 0);

k6 run tests/load-checkout.js \
  --out prometheus-remote-write=http://prometheus:9090/api/v1/write \
  --summary-export summary.json

# 1. Зарегистрируйтесь: https://grafana.com/auth/sign-up/create-user
# 2. Получите Prometheus remote write URL и токен
# 3. Запустите тест:
K6_PROMETHEUS_REMOTE_URL=https://prometheus-xxx.grafana.net/api/prom/push \
K6_PROMETHEUS_INSECURE_SKIP_TLS_VERIFY=false \
k6 run tests/load-checkout.js \
  --out experimental-prometheus-rw

# docker-compose.yml
version: '3'
services:
  influxdb:
    image: influxdb:2.7
    ports:
      - "8086:8086"
    environment:
      DOCKER_INFLUXDB_INIT_MODE: setup
      DOCKER_INFLUXDB_INIT_USERNAME: admin
      DOCKER_INFLUXDB_INIT_PASSWORD: adminpassword
      DOCKER_INFLUXDB_INIT_ORG: myorg
      DOCKER_INFLUXDB_INIT_BUCKET: k6
 
  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
 
# Запуск:
docker-compose up -d
 
# Тест:
k6 run tests/load-checkout.js --out influxdb=http://localhost:8086/k6

# Критерии Go/No-Go для релизов
 
## Smoke test (обязательно перед каждым PR)
 
- ✅ Go: checks > 95%, http_req_failed < 5%, p95 < 1s
- ⚠️ Review: checks 90-95% (проверить причину)
- ❌ No-Go: checks < 90% или http_req_failed > 10%
 
## Load test (обязательно перед major release)
 
- ✅ Go: p95 в SLO, error rate < 1%, деградация к baseline < 10%
- ⚠️ Review: деградация 10-20% (обсудить с владельцем продукта)
- ❌ No-Go: p95 вне SLO, error rate > 2%, деградация > 20%
 
## Stress test (перед big sale / маркетинговая кампания)
 
- ✅ Go: нашли breakpoint > ожидаемого пика × 1.5
- ⚠️ Review: breakpoint близко к пику (нужен plan масштабирования)
- ❌ No-Go: breakpoint < ожидаемого пика
 
## Ответственные
 
- За запуск тестов: DevOps / QA
- За анализ результатов: Tech Lead / Performance Engineer
- За решение Go/No-Go: Product Owner + Tech Lead

# Load Test Report: Checkout Flow
 
**Дата:** 2024-01-15
**Версия:** v1.3.0
**Тип теста:** Load (ramping-vus, 50 VU, 10 min)
**Dashboard:** https://grafana.yourapp.com/d/k6-checkout
 
## Результаты
 
| Метрика     | Baseline | Current | Diff  | Status    |
| ----------- | -------- | ------- | ----- | --------- |
| p95 latency | 450ms    | 520ms   | +15%  | ⚠️        |
| p99 latency | 850ms    | 980ms   | +15%  | ⚠️        |
| Error rate  | 0.2%     | 0.3%    | +50%  | ✅ (< 1%) |
| Checks      | 98.5%    | 98.1%   | -0.4% | ✅        |
| RPS         | 85       | 82      | -3%   | ✅        |
 
## Анализ
 
**Bottleneck:** Рост latency на 15% к baseline
 
**Причина:**
 
- http_req_waiting вырос с 400ms до 480ms
- CPU сервиса стабильный (40%)
- БД latency выросла с 50ms до 120ms
- Обнаружено: N+1 query в новом endpoint `/api/orders/items`
 
**Триангуляция:**
 
- Grafana: http_req_waiting ↑ 20%
- Traces (Jaeger): span `orders.getItems` = 80% времени
- Logs: "Slow query: SELECT \* FROM order_items WHERE..."
 
## Решение
 
⚠️ **Review рекомендован**
 
**Рекомендация:**
 
- Оптимизировать N+1 query (JOIN вместо loop)
- Или: принять деградацию +15% (укладывается в SLO < 800ms)
 
**Решение владельца продукта:** [Заполнить]
 
**Действия:**
 
- [ ] Создать задачу на оптимизацию БД: JIRA-123
- [ ] Запланировать повторный тест после фикса
- [ ] Обновить baseline если принимаем деградацию