A/B-тесты как шлюзы качества

Updated Jul 2026

За пределами продуктового экспериментирования

A/B-тестирование обычно ассоциируется с продуктовым экспериментированием — проверка того, конвертирует ли зелёная кнопка лучше, чем синяя. Но QA-архитекторы могут использовать ту же инфраструктуру для валидации качества. Ключевая идея: если вы можете измерить качество пользовательского опыта в варианте A по сравнению с вариантом B, вы можете контролировать релизы на основе этих измерений.

Метрики качества для A/B-тестирования

Мощь использования инфраструктуры A/B-тестирования для качества в том, что вы получаете каузальные доказательства, а не просто корреляцию. Поскольку пользователи случайным образом распределяются в контрольную и экспериментальную группы, любое различие в метриках вызвано изменением кода, а не смешивающими факторами.

Статистическая значимость для шлюзов качества

Решения шлюзов качества должны быть статистически строгими. Наивное сравнение («доля ошибок канарейки 2,1% против контроля 2,0%») может привести к ложным выводам.

Z-тест пропорций для шлюзов качества

# quality_gate_statistics.py
import numpy as np
from scipy import stats

def is_canary_safe(control_errors, canary_errors, significance_level=0.05):
    """
    Determine if the canary version is statistically no worse than control.
    Uses a one-tailed proportions z-test.

    Args:
        control_errors: list of 0/1 (0=success, 1=error) for control group
        canary_errors: list of 0/1 for canary group
        significance_level: p-value threshold (default 0.05)

    Returns: (is_safe: bool, p_value: float, details: str)
    """
    n_control = len(control_errors)
    n_canary = len(canary_errors)

    p_control = sum(control_errors) / n_control
    p_canary = sum(canary_errors) / n_canary

    # Pooled proportion under the null hypothesis
    p_pool = (sum(control_errors) + sum(canary_errors)) / (n_control + n_canary)

    # Standard error of the difference
    se = np.sqrt(p_pool * (1 - p_pool) * (1/n_control + 1/n_canary))

    if se == 0:
        return True, 1.0, "No errors in either group"

    # Z-score: is canary WORSE than control?
    z = (p_canary - p_control) / se
    p_value = 1 - stats.norm.cdf(z)  # one-tailed test

    is_safe = p_value > significance_level

    details = (
        f"Control error rate: {p_control:.4%} ({sum(control_errors)}/{n_control})\n"
        f"Canary error rate:  {p_canary:.4%} ({sum(canary_errors)}/{n_canary})\n"
        f"Z-score: {z:.3f}, P-value: {p_value:.4f}\n"
        f"Decision: {'SAFE - no significant degradation' if is_safe else 'UNSAFE - canary is significantly worse'}"
    )

    return is_safe, p_value, details


# Example: control vs canary with identical error rates
control_results = [0]*9800 + [1]*200      # 2.0% error rate (10,000 requests)
canary_results = [0]*980 + [1]*20          # 2.0% error rate (1,000 requests)

safe, p_val, details = is_canary_safe(control_results, canary_results)
print(details)
# Control error rate: 2.0000%
# Canary error rate:  2.0000%
# Z-score: 0.000, P-value: 0.5000
# Decision: SAFE - no significant degradation

Требования к размеру выборки

Количество запросов, необходимое для статистически корректного сравнения, зависит от базовой доли ошибок и минимального обнаруживаемого эффекта:

Практический вывод: Для сервисов с очень низкой долей ошибок вам нужен либо большой объём трафика, либо более длинные окна наблюдения для достижения статистической значимости.

Многометричные шлюзы качества

Реальные шлюзы качества оценивают несколько метрик одновременно:

# multi_metric_quality_gate.py
from dataclasses import dataclass
from enum import Enum

class GateResult(Enum):
    PASS = "pass"
    WARN = "warn"
    FAIL = "fail"

@dataclass
class MetricGate:
    name: str
    metric_type: str           # "lower_is_better" or "higher_is_better"
    critical: bool             # if True, failure blocks deployment
    max_degradation_pct: float # maximum allowed degradation (e.g., 0.10 = 10%)

def evaluate_quality_gates(
    control_metrics: dict,
    canary_metrics: dict,
    gates: list[MetricGate]
) -> dict:
    """Evaluate all quality gates and produce a deployment decision."""
    results = []
    any_critical_fail = False

    for gate in gates:
        control_val = control_metrics[gate.name]
        canary_val = canary_metrics[gate.name]

        if gate.metric_type == "lower_is_better":
            # e.g., error rate, latency -- canary should not be higher
            degradation = (canary_val - control_val) / control_val if control_val > 0 else 0
            passed = degradation < gate.max_degradation_pct
        else:
            # e.g., throughput, conversion -- canary should not be lower
            degradation = (control_val - canary_val) / control_val if control_val > 0 else 0
            passed = degradation < gate.max_degradation_pct

        result = GateResult.PASS if passed else (GateResult.FAIL if gate.critical else GateResult.WARN)

        if result == GateResult.FAIL and gate.critical:
            any_critical_fail = True

        results.append({
            "gate": gate.name,
            "control": control_val,
            "canary": canary_val,
            "degradation": f"{degradation:.2%}",
            "threshold": f"{gate.max_degradation_pct:.0%}",
            "result": result.value,
            "critical": gate.critical,
        })

    return {
        "decision": "ROLLBACK" if any_critical_fail else "PROMOTE",
        "gates": results,
    }


# Define quality gates
gates = [
    MetricGate("error_rate", "lower_is_better", critical=True, max_degradation_pct=0.50),
    MetricGate("p99_latency_ms", "lower_is_better", critical=True, max_degradation_pct=0.25),
    MetricGate("p50_latency_ms", "lower_is_better", critical=False, max_degradation_pct=0.15),
    MetricGate("conversion_rate", "higher_is_better", critical=False, max_degradation_pct=0.05),
    MetricGate("cpu_usage_pct", "lower_is_better", critical=False, max_degradation_pct=0.30),
]

# Example metrics
result = evaluate_quality_gates(
    control_metrics={"error_rate": 0.02, "p99_latency_ms": 450, "p50_latency_ms": 120,
                     "conversion_rate": 0.034, "cpu_usage_pct": 55},
    canary_metrics={"error_rate": 0.021, "p99_latency_ms": 480, "p50_latency_ms": 125,
                    "conversion_rate": 0.033, "cpu_usage_pct": 58},
    gates=gates,
)
print(f"Decision: {result['decision']}")
for g in result['gates']:
    print(f"  {g['gate']}: {g['result']} (degradation: {g['degradation']})")

Автоматизированный пайплайн шлюзов качества

Интегрируйте шлюзы качества в ваш пайплайн деплоя:

# .github/workflows/canary-quality-gate.yml
name: Canary Quality Gate
on:
  workflow_dispatch:
    inputs:
      canary_version:
        description: 'Docker image tag for canary'
        required: true

jobs:
  canary-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Deploy canary (5% traffic)
        run: |
          kubectl set image deployment/app-canary \
            app=${{ inputs.canary_version }}
          kubectl patch virtualservice app-vs --type merge -p '
            {"spec":{"http":[{"route":[
              {"destination":{"host":"app-stable"},"weight":95},
              {"destination":{"host":"app-canary"},"weight":5}
            ]}]}}'

      - name: Wait for observation window
        run: sleep 900  # 15 minutes

      - name: Run quality gate analysis
        run: |
          python scripts/quality_gate.py \
            --prometheus-url ${{ secrets.PROMETHEUS_URL }} \
            --control-label "version=stable" \
            --canary-label "version=${{ inputs.canary_version }}" \
            --window 15m

      - name: Promote or rollback
        if: always()
        run: |
          if [ "${{ steps.quality-gate.outcome }}" == "success" ]; then
            echo "Promoting canary to stable"
            kubectl set image deployment/app-stable \
              app=${{ inputs.canary_version }}
          else
            echo "Rolling back canary"
            kubectl scale deployment/app-canary --replicas=0
          fi

Когда A/B-тестирование лучше простого канареечного

Используйте простой канареечный анализ для инфраструктурных и бэкенд-изменений. Используйте A/B шлюзы качества, когда изменение влияет на пользовательское поведение, где важны метрики вовлечённости и бизнеса.