В чем разница между нагрузочным и стресс тестом?

В чем разница между нагрузочным и стресс тестом?

Это два разных типа тестирования производительности, которые используются для разных целей.

1. Нагрузочный тест (Load Test)

Нагрузочный тест проверяет, как система ведёт себя под ожидаемой нормальной нагрузкой. Целью является убедиться, что система работает корректно и быстро при обычных условиях.

Характеристики:

• Нагрузка остаётся стабильной или увеличивается постепенно
• Ищем нормальные метрики: время ответа, пропускная способность
• Проверяем, соответствует ли система требованиям производительности
• Пользователи имеют нормальное поведение

# Пример нагрузочного теста с помощью locust
from locust import HttpUser, task, between

class UserBehavior(HttpUser):
    wait_time = between(1, 3)  # Пользователь ждёт 1-3 секунды между запросами
    
    @task(1)
    def index(self):
        # GET /api/users — нормальный запрос
        self.client.get("/api/users")
    
    @task(2)
    def get_user(self):
        # GET /api/users/1 — ещё один нормальный запрос
        self.client.get("/api/users/1")

# Запуск: locust -f loadtest.py --users 100 --spawn-rate 10
# 100 одновременных пользователей, растущих по 10 в секунду

Сценарии нагрузочного теста:

# Проверяем, что система обрабатывает 1000 запросов в секунду
# Время ответа < 200ms
# CPU использование < 70%
# Memory < 2GB

2. Стресс-тест (Stress Test)

Стресс-тест проверяет, как система ведёт себя при экстремальной нагрузке за пределами обычных параметров. Целью является найти предел (breaking point) системы.

Характеристики:

• Нагрузка постоянно растёт или сразу очень велика
• Ищем точку отказа: когда система начинает падать
• Проверяем graceful degradation: что происходит при перегрузке
• Поведение пользователей может быть экстремальным

# Пример стресс-теста
from locust import HttpUser, task, between

class StressTest(HttpUser):
    wait_time = between(0.1, 0.5)  # Очень короткие интервалы!
    
    @task(10)
    def stress_api(self):
        # Много одновременных запросов
        self.client.get("/api/expensive-operation")
    
    @task(10)
    def stress_db(self):
        # Запросы, требующие БД
        self.client.post("/api/users", json={"name": "Test"})

# Запуск: locust -f stresstest.py --users 10000 --spawn-rate 500
# 10000 пользователей! Растут по 500 в секунду!

3. Ключевые отличия в таблице

4. Практический пример: нагрузочный тест

# load_test.py — нормальная нагрузка
from locust import HttpUser, task, between

class NormalUser(HttpUser):
    wait_time = between(2, 5)
    
    @task
    def view_homepage(self):
        self.client.get("/")
    
    @task(3)
    def search(self):
        self.client.get("/search?q=python")
    
    @task(2)
    def view_product(self):
        self.client.get("/products/123")

# locust -f load_test.py --users 100 --spawn-rate 5 --run-time 10m
# Результат:
# - 100 пользователей одновременно
# - Растут по 5 в секунду
# - Работает 10 минут
# - Проверяем, что время ответа нормальное

Что мы измеряем:

• Response time: 100ms, 95th percentile: 200ms ✓
• Throughput: 1000 req/sec ✓
• Error rate: < 1% ✓
• CPU: 45% ✓
• Memory: 1.2 GB ✓

5. Практический пример: стресс-тест

# stress_test.py — экстремальная нагрузка
from locust import HttpUser, task, between

class StressedUser(HttpUser):
    wait_time = between(0, 0.1)  # Почти без задержек
    
    @task(50)  # Очень много задач
    def heavy_operation(self):
        self.client.get("/api/expensive-calculation")
    
    @task(50)
    def database_intensive(self):
        self.client.post("/api/users", json={"name": f"User{int(time())}"})

# locust -f stress_test.py --users 10000 --spawn-rate 1000 --run-time 5m
# Результат:
# - Response time: 5000ms (очень медленно)
# - Error rate: 15% (много ошибок!)
# - Throughput упал с 1000 до 100 req/sec
# - Memory: 5GB (растёт неконтролируемо)
# - Server начинает возвращать 503 Service Unavailable

6. Что происходит при стресс-тесте?

Нормальный трафик:      100 req/sec
Нагрузочный тест:     1,000 req/sec — система справляется
Стресс-тест:        10,000 req/sec — система перегружена

Результаты стресс-теста:
- Connection timeouts (истекло время подключения)
- 503 Service Unavailable (сервер перегружен)
- Memory leaks (утечки памяти обнаруживаются)
- Deadlocks (взаимные блокировки в БД)
- Cascading failures (падение каскадом)

7. Настоящие примеры из практики

Нагрузочный тест для веб-магазина:

# Ожидаемая нагрузка: 500 одновременных пользователей
# Цель: убедиться, что система работает нормально

locust -f load_test.py \
  --users 500 \
  --spawn-rate 50 \
  --run-time 30m \
  --headless \
  --host https://myshop.com

# Результаты:
# Response time p50: 120ms ✓
# Response time p95: 250ms ✓
# Error rate: 0.1% ✓
# Throughput: 5000 req/sec ✓

Стресс-тест для Black Friday:

# Ожидаемая экстремальная нагрузка: 50,000 одновременных пользователей
# Цель: найти точку отказа и спланировать масштабирование

locust -f stress_test.py \
  --users 50000 \
  --spawn-rate 2000 \
  --run-time 15m \
  --headless \
  --host https://myshop.com

# Результаты:
# System падает при 35,000 пользователей
# Response time достигает 8000ms
# Database connections исчерпаны (max 100)
# Нужно масштабировать БД и добавить load balancer

8. Инструменты для тестирования

Нагрузочное тестирование:

• Locust (Python) — легко писать сценарии на Python
• JMeter — визуальный инструмент
• K6 — современный tool с JavaScript
• Artillery — DevOps friendly

Стресс-тестирование:

• Те же инструменты, но с экстремальными параметрами
• ab (Apache Bench) — простой CLI tool
• wrk — быстрый HTTP benchmarking tool

9. Пример с использованием K6

// load_test.js — нагрузочный тест
import http from "k6/http";
import { check, sleep } from "k6";

export const options = {
  stages: [
    { duration: "2m", target: 100 },  // Растёт до 100 пользователей за 2 минуты
    { duration: "5m", target: 100 },  // Остаётся на 100 минут 5
    { duration: "2m", target: 0 },    // Спадает за 2 минуты
  ],
};

export default function () {
  const res = http.get("https://api.example.com/users");
  check(res, {
    "status is 200": (r) => r.status === 200,
    "response time < 200ms": (r) => r.timings.duration < 200,
  });
  sleep(1);
}

// stress_test.js — стресс-тест
import http from "k6/http";

export const options = {
  stages: [
    { duration: "30s", target: 1000 },   // Быстро растёт до 1000
    { duration: "1m", target: 5000 },    // Растёт до 5000
    { duration: "30s", target: 10000 },  // Экстремальная нагрузка
  ],
};

export default function () {
  http.get("https://api.example.com/expensive-operation");
  // Без sleep — максимальная нагрузка!
}

10. Когда использовать каждый тип?

Нагрузочный тест:

• Перед релизом в production
• Для мониторинга регрессии производительности
• Для проверки SLA (Service Level Agreement)
• Еженедельно/ежемесячно

Стресс-тест:

• Перед масштабными событиями (Black Friday, праздники)
• Для планирования capacity (мощности)
• Для поиска bottlenecks
• Для проверки graceful degradation
• Раз в квартал или перед major changes

Итог

• Нагрузочный тест — убедиться, что система работает корректно при ожидаемой нагрузке
• Стресс-тест — найти точку отказа при экстремальной нагрузке
• Нагрузочный тест измеряет: response time, throughput, error rate
• Стресс-тест ищет: breaking point, recovery capability, graceful degradation