Тестирование Blue-Green Развертываний: Полное Руководство для DevOps Команд

#!/bin/bash
# smoke-test.sh - Базовая проверка health для среды green

GREEN_URL="https://green.example.com"

# Проверить, что приложение отвечает
if ! curl -f -s "${GREEN_URL}/health" > /dev/null; then
    echo "❌ Эндпоинт health не отвечает"
    exit 1
fi

# Проверить подключение к базе данных
if ! curl -f -s "${GREEN_URL}/api/db-check" | grep -q "OK"; then
    echo "❌ Подключение к базе данных не удалось"
    exit 1
fi

# Проверить критические зависимости
for service in redis kafka elasticsearch; do
    if ! curl -f -s "${GREEN_URL}/api/check/${service}" | grep -q "healthy"; then
        echo "❌ Проверка зависимости ${service} не удалась"
        exit 1
    fi
done

echo "✅ Все smoke tests прошли успешно"

# test_green_integration.py
import pytest
import requests

GREEN_BASE_URL = "https://green.example.com"

def test_user_registration_flow():
    """Тест полного процесса регистрации пользователя"""
    # Создать пользователя
    response = requests.post(f"{GREEN_BASE_URL}/api/users", json={
        "email": "test@example.com",
        "password": "SecurePass123!"
    })
    assert response.status_code == 201
    user_id = response.json()["id"]

    # Проверить отправку email
    email_check = requests.get(f"{GREEN_BASE_URL}/api/emails/{user_id}")
    assert email_check.json()["type"] == "verification"

    # Завершить верификацию
    token = email_check.json()["token"]
    verify = requests.post(f"{GREEN_BASE_URL}/api/verify", json={"token": token})
    assert verify.status_code == 200

def test_payment_processing():
    """Проверить интеграцию с платежным шлюзом"""
    response = requests.post(f"{GREEN_BASE_URL}/api/payments", json={
        "amount": 1000,
        "currency": "USD",
        "method": "card"
    })
    assert response.status_code == 200
    assert response.json()["status"] == "processed"

-- validate_migration.sql
-- Выполните эти проверки перед переключением трафика

-- 1. Проверить версию схемы
SELECT version FROM schema_migrations
ORDER BY version DESC LIMIT 1;
-- Ожидается: 20251102_latest_migration

-- 2. Проверить согласованность данных
SELECT
    (SELECT COUNT(*) FROM users) as total_users,
    (SELECT COUNT(*) FROM users WHERE created_at > NOW() - INTERVAL '1 hour') as recent_users;
-- recent_users должно быть 0 (green новая)

-- 3. Валидировать индексы
SELECT schemaname, tablename, indexname
FROM pg_indexes
WHERE schemaname = 'public'
AND tablename IN ('users', 'orders', 'products');
-- Все ожидаемые индексы должны существовать

-- 4. Проверить ограничения внешних ключей
SELECT COUNT(*) FROM information_schema.table_constraints
WHERE constraint_type = 'FOREIGN KEY'
AND table_schema = 'public';
-- Должно совпадать с количеством в среде blue

# prometheus-alerts.yml - Мониторинг среды green
groups:
  - name: blue_green_deployment
    interval: 30s
    rules:
      # Обнаружение всплеска латентности
      - alert: GreenLatencyHigh
        expr: histogram_quantile(0.99, rate(http_request_duration_seconds_bucket{env="green"}[5m])) > 1.5
        for: 2m
        annotations:
          summary: "Среда green показывает высокую латентность"

      # Увеличение частоты ошибок
      - alert: GreenErrorRateHigh
        expr: rate(http_requests_total{env="green", status=~"5.."}[5m]) > 0.05
        for: 1m
        annotations:
          summary: "Частота ошибок green превышает 5%"

      # Насыщение трафика
      - alert: GreenSaturation
        expr: rate(http_requests_total{env="green"}[1m]) > 10000
        for: 5m
        annotations:
          summary: "Среда green обрабатывает высокую нагрузку"

# parallel_test.py - Сравнить ответы blue vs green
import asyncio
import aiohttp
import statistics

async def compare_endpoints(endpoint, iterations=100):
    """Сравнить время ответа и результаты между blue и green"""
    blue_times = []
    green_times = []
    discrepancies = []

    async with aiohttp.ClientSession() as session:
        for i in range(iterations):
            # Тест blue
            start = asyncio.get_event_loop().time()
            async with session.get(f"https://blue.example.com{endpoint}") as resp:
                blue_result = await resp.json()
                blue_times.append(asyncio.get_event_loop().time() - start)

            # Тест green
            start = asyncio.get_event_loop().time()
            async with session.get(f"https://green.example.com{endpoint}") as resp:
                green_result = await resp.json()
                green_times.append(asyncio.get_event_loop().time() - start)

            # Проверить на расхождения
            if blue_result != green_result:
                discrepancies.append({
                    'iteration': i,
                    'blue': blue_result,
                    'green': green_result
                })

    return {
        'blue_avg': statistics.mean(blue_times),
        'green_avg': statistics.mean(green_times),
        'blue_p99': statistics.quantiles(blue_times, n=100)[98],
        'green_p99': statistics.quantiles(green_times, n=100)[98],
        'discrepancies': len(discrepancies),
        'discrepancy_rate': len(discrepancies) / iterations
    }

# Запустить сравнение
results = asyncio.run(compare_endpoints('/api/products'))
print(f"Blue среднее: {results['blue_avg']:.3f}s, Green среднее: {results['green_avg']:.3f}s")
print(f"Частота расхождений: {results['discrepancy_rate']*100:.2f}%")

# nginx.conf - Shadow traffic в среду green
upstream blue_backend {
    server blue.example.com:8080;
}

upstream green_backend {
    server green.example.com:8080;
}

server {
    listen 80;

    location / {
        # Основной трафик идет в blue
        proxy_pass http://blue_backend;

        # Дублировать трафик в green (асинхронно, ответ не используется)
        mirror /mirror;
        mirror_request_body on;
    }

    location /mirror {
        internal;
        proxy_pass http://green_backend$request_uri;
        proxy_set_header X-Shadow-Request "true";
    }
}

// synthetic-monitor.js - Стиль Datadog/New Relic
const puppeteer = require('puppeteer');

async function runSyntheticTest(environment) {
    const browser = await puppeteer.launch();
    const page = await browser.newPage();

    try {
        // Мониторить время загрузки страницы
        const startTime = Date.now();
        await page.goto(`https://${environment}.example.com`);
        const loadTime = Date.now() - startTime;

        // Тестировать критический путь пользователя
        await page.click('#search-input');
        await page.type('#search-input', 'test product');
        await page.click('#search-button');
        await page.waitForSelector('.search-results');

        // Добавить в корзину
        await page.click('.product-card:first-child .add-to-cart');
        await page.waitForSelector('.cart-notification');

        // Проверить корзину
        await page.click('#cart-icon');
        const cartItems = await page.$$('.cart-item');

        return {
            success: cartItems.length > 0,
            loadTime: loadTime,
            environment: environment,
            timestamp: new Date().toISOString()
        };
    } catch (error) {
        return {
            success: false,
            error: error.message,
            environment: environment
        };
    } finally {
        await browser.close();
    }
}

// Запускать каждые 5 минут
setInterval(async () => {
    const greenResults = await runSyntheticTest('green');
    if (!greenResults.success) {
        // Оповестить при сбое
        console.error('❌ Синтетический тест green не прошел:', greenResults);
    }
}, 5 * 60 * 1000);

# db_validator.py - Сравнить состояния баз данных
import psycopg2
from datetime import datetime, timedelta

def compare_databases(blue_conn, green_conn):
    """Сравнить критические метрики базы данных между средами"""
    checks = []

    # 1. Количество строк должно совпадать (с допуском на недавние записи)
    tables = ['users', 'orders', 'products', 'inventory']
    for table in tables:
        blue_count = execute_query(blue_conn, f"SELECT COUNT(*) FROM {table}")
        green_count = execute_query(green_conn, f"SELECT COUNT(*) FROM {table}")

        # Разрешить 1% разницы для активных записей
        tolerance = blue_count * 0.01
        if abs(blue_count - green_count) > tolerance:
            checks.append({
                'table': table,
                'status': 'FAIL',
                'blue_count': blue_count,
                'green_count': green_count,
                'difference': abs(blue_count - green_count)
            })
        else:
            checks.append({
                'table': table,
                'status': 'PASS'
            })

    # 2. Проверить репликацию недавних данных
    cutoff = datetime.now() - timedelta(hours=1)
    for table in ['orders', 'user_sessions']:
        query = f"SELECT COUNT(*) FROM {table} WHERE updated_at > %s"
        blue_recent = execute_query(blue_conn, query, (cutoff,))
        green_recent = execute_query(green_conn, query, (cutoff,))

        # Green должен иметь похожие или более свежие данные
        if green_recent < blue_recent * 0.95:
            checks.append({
                'check': f'{table}_recent_data',
                'status': 'FAIL',
                'message': 'Green отсутствуют недавние обновления'
            })

    return checks

def execute_query(conn, query, params=None):
    with conn.cursor() as cur:
        cur.execute(query, params)
        return cur.fetchone()[0]

# .ebextensions/blue-green-config.yml
option_settings:
  aws:elasticbeanstalk:command:
    DeploymentPolicy: Immutable
    Timeout: "600"

  # Конфигурация health check
  aws:elasticbeanstalk:healthreporting:system:
    SystemType: enhanced
    EnhancedHealthAuthEnabled: true

  # Настройки rolling развертывания
  aws:autoscaling:updatepolicy:rollingupdate:
    RollingUpdateEnabled: true
    MaxBatchSize: 1
    MinInstancesInService: 2
    PauseTime: "PT5M"  # Пауза 5 минут между партиями

# Записать в обе старую и новую схему
def save_user(user_data):
    # Записать в старую схему (blue)
    old_db.users.insert({
        'name': user_data['name'],
        'email': user_data['email']
    })

    # Записать в новую схему (green)
    new_db.users.insert({
        'full_name': user_data['name'],
        'email_address': user_data['email'],
        'created_at': datetime.now()
    })

def get_user(user_id):
    # Читать из новой схемы
    user = new_db.users.find_one({'_id': user_id})

    # Асинхронная валидация против старой схемы
    asyncio.create_task(validate_data(user_id, user))

    return user

async def validate_data(user_id, new_data):
    old_data = old_db.users.find_one({'_id': user_id})
    if not data_matches(old_data, new_data):
        log_discrepancy(user_id, old_data, new_data)

# Ключевые Показатели Эффективности (KPIs)
response_time:
  p50: < 100ms
  p95: < 300ms
  p99: < 1000ms

error_rate:
  warning: > 0.5%
  critical: > 1%

throughput:
  min_rps: 1000  # Должен обрабатывать нормальную нагрузку
  max_rps: 5000  # Должен обрабатывать пиковую нагрузку

resource_usage:
  cpu: < 70%
  memory: < 80%
  disk: < 75%

dependencies:
  database_connections: < 80% от пула
  cache_hit_rate: > 90%
  queue_depth: < 1000 сообщений

# traffic_controller.py - Постепенное переключение трафика
import time

def gradual_traffic_shift(duration_minutes=60):
    """Переключить трафик с blue на green за указанную длительность"""
    steps = [1, 5, 10, 25, 50, 75, 100]  # Процент на green
    step_duration = duration_minutes * 60 / len(steps)

    for percentage in steps:
        print(f"Переключение {percentage}% трафика на green...")
        update_load_balancer(green_weight=percentage, blue_weight=100-percentage)

        # Мониторить проблемы
        time.sleep(step_duration)
        metrics = get_green_metrics()

        if metrics['error_rate'] > 0.01 or metrics['p99_latency'] > 1.5:
            print(f"❌ Метрики деградировали при {percentage}%, откат")
            rollback_to_blue()
            return False

        print(f"✅ {percentage}% трафика обрабатывается хорошо")

    return True

# auto_rollback.py
from prometheus_api_client import PrometheusConnect

prom = PrometheusConnect(url="http://prometheus:9090")

def check_rollback_conditions():
    """Проверить, должен ли сработать автоматический откат"""

    # 1. Всплеск частоты ошибок
    error_rate_query = 'rate(http_requests_total{env="green",status=~"5.."}[5m])'
    error_rate = prom.custom_query(error_rate_query)[0]['value'][1]
    if float(error_rate) > 0.05:  # 5% частота ошибок
        return True, "Частота ошибок превысила 5%"

    # 2. Деградация латентности
    latency_query = 'histogram_quantile(0.99, rate(http_request_duration_seconds_bucket{env="green"}[5m]))'
    p99_latency = prom.custom_query(latency_query)[0]['value'][1]
    if float(p99_latency) > 2.0:  # 2 секунды p99
        return True, "Латентность P99 превысила 2 секунды"

    # 3. Истощение ресурсов
    cpu_query = 'avg(rate(container_cpu_usage_seconds_total{env="green"}[5m]))'
    cpu_usage = prom.custom_query(cpu_query)[0]['value'][1]
    if float(cpu_usage) > 0.9:  # 90% CPU
        return True, "Использование CPU превысило 90%"

    return False, None

# Запускать каждые 30 секунд
while True:
    should_rollback, reason = check_rollback_conditions()
    if should_rollback:
        print(f"🚨 АВТОМАТИЧЕСКИЙ ОТКАТ СРАБОТАЛ: {reason}")
        execute_rollback()
        send_alert(reason)
        break
    time.sleep(30)

# ПЛОХО - Изменение, нарушающее совместимость
# Миграция 1: Добавить NOT NULL колонку
ALTER TABLE users ADD COLUMN phone VARCHAR(20) NOT NULL;

# ХОРОШО - Обратно совместимо
# Миграция 1: Добавить nullable колонку
ALTER TABLE users ADD COLUMN phone VARCHAR(20) NULL;

# Миграция 2: Заполнить данные
UPDATE users SET phone = 'UNKNOWN' WHERE phone IS NULL;

# Миграция 3: Добавить ограничение (развернуть после полного перехода трафика на green)
ALTER TABLE users ALTER COLUMN phone SET NOT NULL;

# ПЛОХО - Сессии в памяти (потеряны при переключении среды)
from flask import Flask, session
app = Flask(__name__)
app.secret_key = 'secret'

@app.route('/login')
def login():
    session['user_id'] = 123  # Хранится локально, потеряно при переключении

# ХОРОШО - Сессии на основе Redis (постоянные между средами)
from flask import Flask
from flask_session import Session
import redis

app = Flask(__name__)
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.from_url('redis://shared-redis:6379')
Session(app)

@app.route('/login')
def login():
    session['user_id'] = 123  # Хранится в Redis, переживает переключение

# rate_limit_manager.py
class EnvironmentAwareRateLimiter:
    def __init__(self, redis_client):
        self.redis = redis_client
        self.env = os.getenv('ENVIRONMENT')  # 'blue' или 'green'

    def check_limit(self, api_name, limit_per_hour):
        """Проверить ограничение частоты с ключами, специфичными для среды"""
        key = f"ratelimit:{self.env}:{api_name}:{datetime.now().hour}"
        current = self.redis.incr(key)
        self.redis.expire(key, 3600)  # TTL 1 час

        return current <= limit_per_hour

    def use_quota(self, api_name):
        """Использовать квоту из общего пула, если среда blue"""
        if self.env == 'blue':
            # Использовать производственную квоту
            return self.check_limit(api_name, 10000)
        else:
            # Использовать сокращенную квоту для тестирования green
            return self.check_limit(api_name, 1000)

<!-- ПЛОХО - Тот же URL, кэш может выдать старую версию -->
<script src="/static/app.js"></script>

<!-- ХОРОШО - Уникальный URL для каждой сборки, нет проблем с кэшем -->
<script src="/static/app.js?v=build-20251102-1534"></script>

<!-- ЛУЧШЕ - Хэширование на основе содержимого -->
<script src="/static/app.a8f3d9e2.js"></script>

# blue-green.tf - Полная настройка blue-green
resource "aws_lb_target_group" "blue" {
  name     = "app-blue-tg"
  port     = 8080
  protocol = "HTTP"
  vpc_id   = aws_vpc.main.id

  health_check {
    path                = "/health"
    interval            = 30
    timeout             = 5
    healthy_threshold   = 2
    unhealthy_threshold = 2
  }
}

resource "aws_lb_target_group" "green" {
  name     = "app-green-tg"
  port     = 8080
  protocol = "HTTP"
  vpc_id   = aws_vpc.main.id

  health_check {
    path                = "/health"
    interval            = 30
    timeout             = 5
    healthy_threshold   = 2
    unhealthy_threshold = 2
  }
}

resource "aws_lb_listener_rule" "production" {
  listener_arn = aws_lb_listener.main.arn
  priority     = 100

  action {
    type             = "forward"
    target_group_arn = var.active_environment == "blue" ?
                       aws_lb_target_group.blue.arn :
                       aws_lb_target_group.green.arn
  }

  condition {
    path_pattern {
      values = ["/*"]
    }
  }
}

# appspec.yml - Конфигурация CodeDeploy
version: 0.0
Resources:
  - TargetService:
      Type: AWS::ECS::Service
      Properties:
        TaskDefinition: "arn:aws:ecs:us-east-1:123456:task-definition/app:2"
        LoadBalancerInfo:
          ContainerName: "app"
          ContainerPort: 8080
        PlatformVersion: "LATEST"

Hooks:
  - BeforeInstall: "scripts/pre-deployment-tests.sh"
  - AfterInstall: "scripts/smoke-tests.sh"
  - AfterAllowTestTraffic: "scripts/integration-tests.sh"
  - BeforeAllowTraffic: "scripts/validation.sh"
  - AfterAllowTraffic: "scripts/post-deployment-monitoring.sh"

# flagger-canary.yml
apiVersion: flagger.app/v1beta1
kind: Canary
metadata:
  name: app
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: app
  service:
    port: 8080
  analysis:
    interval: 1m
    threshold: 5
    maxWeight: 50
    stepWeight: 10
    metrics:
    - name: request-success-rate
      thresholdRange:
        min: 99
      interval: 1m
    - name: request-duration
      thresholdRange:
        max: 500
      interval: 1m
    webhooks:
    - name: load-test
      url: http://flagger-loadtester/
      timeout: 5s
      metadata:
        cmd: "hey -z 1m -q 10 -c 2 http://app:8080/"