Тестирование резервного копирования и восстановления после сбоев: Полное руководство по валидации RTO и RPO

# Пример целей DR по уровням систем
tier_1_критичные:
  системы: [обработка_платежей, аутентификация_пользователей]
  rto: 1 час
  rpo: 15 минут
  частота_бэкапа: непрерывная_репликация

tier_2_важные:
  системы: [управление_заказами, инвентарь]
  rto: 4 часа
  rpo: 1 час
  частота_бэкапа: ежечасно

tier_3_стандартные:
  системы: [отчёты, аналитика]
  rto: 24 часа
  rpo: 24 часа
  частота_бэкапа: ежедневно

#!/bin/bash
# backup_validation.sh - Автоматизированная проверка целостности бэкапа

set -e

BACKUP_PATH="/backups/daily"
CHECKSUM_FILE="/var/log/backup_checksums.txt"
SLACK_WEBHOOK="${SLACK_WEBHOOK_URL}"

# Проверка существования и актуальности бэкапа
LATEST_BACKUP=$(ls -t ${BACKUP_PATH}/*.tar.gz 2>/dev/null | head -1)

if [ -z "$LATEST_BACKUP" ]; then
    echo "ОШИБКА: Бэкап не найден"
    curl -X POST "$SLACK_WEBHOOK" \
        -H "Content-Type: application/json" \
        -d '{"text": "АЛЕРТ: Бэкап не найден в '"${BACKUP_PATH}"'"}'
    exit 1
fi

# Проверка возраста бэкапа (должен быть меньше 25 часов)
BACKUP_AGE=$(( ($(date +%s) - $(stat -f %m "$LATEST_BACKUP")) / 3600 ))
if [ $BACKUP_AGE -gt 25 ]; then
    echo "ПРЕДУПРЕЖДЕНИЕ: Бэкапу ${BACKUP_AGE} часов"
    exit 1
fi

# Проверка целостности бэкапа
if ! tar -tzf "$LATEST_BACKUP" > /dev/null 2>&1; then
    echo "ОШИБКА: Архив бэкапа повреждён"
    exit 1
fi

# Вычисление и сравнение контрольных сумм
CURRENT_CHECKSUM=$(sha256sum "$LATEST_BACKUP" | cut -d' ' -f1)
echo "$(date): $LATEST_BACKUP - $CURRENT_CHECKSUM" >> "$CHECKSUM_FILE"

echo "Валидация бэкапа успешна: $LATEST_BACKUP"

# db_restore_test.py - Автоматизированное тестирование восстановления БД

import subprocess
import time
import psycopg2
from datetime import datetime

class DatabaseRestoreTest:
    def __init__(self, config):
        self.backup_path = config['backup_path']
        self.test_db = config['test_database']
        self.production_tables = config['critical_tables']
        self.rto_target = config['rto_seconds']

    def run_restore_test(self):
        start_time = time.time()
        results = {
            'timestamp': datetime.now().isoformat(),
            'success': False,
            'rto_met': False,
            'data_integrity': False
        }

        try:
            # Удаление и пересоздание тестовой БД
            self._prepare_test_environment()

            # Восстановление из бэкапа
            restore_start = time.time()
            self._restore_backup()
            restore_duration = time.time() - restore_start

            # Валидация целостности данных
            results['data_integrity'] = self._validate_data()

            # Расчёт RTO
            total_time = time.time() - start_time
            results['restore_duration_seconds'] = restore_duration
            results['total_duration_seconds'] = total_time
            results['rto_met'] = total_time <= self.rto_target
            results['success'] = results['data_integrity'] and results['rto_met']

        except Exception as e:
            results['error'] = str(e)

        return results

    def _restore_backup(self):
        cmd = f"pg_restore -h localhost -d {self.test_db} {self.backup_path}"
        subprocess.run(cmd, shell=True, check=True)

    def _validate_data(self):
        conn = psycopg2.connect(database=self.test_db)
        cursor = conn.cursor()

        for table in self.production_tables:
            cursor.execute(f"SELECT COUNT(*) FROM {table}")
            count = cursor.fetchone()[0]
            if count == 0:
                return False

        conn.close()
        return True

if __name__ == "__main__":
    config = {
        'backup_path': '/backups/latest/db.dump',
        'test_database': 'restore_test',
        'critical_tables': ['users', 'orders', 'payments'],
        'rto_seconds': 3600  # 1 час RTO
    }

    test = DatabaseRestoreTest(config)
    results = test.run_restore_test()
    print(f"Результаты теста восстановления: {results}")

# velero-restore-test.yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: velero-restore-test
  namespace: velero
spec:
  schedule: "0 3 * * 0"  # Еженедельно в воскресенье в 3 утра
  jobTemplate:
    spec:
      template:
        spec:
          serviceAccountName: velero
          containers:

          - name: restore-test
            image: velero/velero:v1.12.0
            command:

            - /bin/sh
            - -c
            - |
              # Получить последний бэкап
              BACKUP_NAME=$(velero backup get -o json | jq -r '.items[-1].metadata.name')

              # Создать восстановление в тестовый namespace
              velero restore create test-restore-${BACKUP_NAME} \
                --from-backup ${BACKUP_NAME} \
                --namespace-mappings production:restore-test \
                --wait

              # Валидация восстановления
              RESTORE_STATUS=$(velero restore get test-restore-${BACKUP_NAME} -o json | jq -r '.status.phase')

              if [ "$RESTORE_STATUS" = "Completed" ]; then
                echo "Тест восстановления успешен"
                # Запуск тестов валидации
                kubectl -n restore-test get pods
                kubectl -n restore-test get pvc
              else
                echo "Тест восстановления провален: $RESTORE_STATUS"
                exit 1
              fi

              # Очистка
              kubectl delete namespace restore-test --wait=true
          restartPolicy: OnFailure

# chaos_dr_test.py - Автоматизированный chaos-тест для валидации DR

from chaoslib.experiment import run_experiment
import json

experiment = {
    "title": "Тест failover базы данных",
    "description": "Валидация автоматического failover на реплику",
    "steady-state-hypothesis": {
        "title": "Приложение отвечает нормально",
        "probes": [
            {
                "type": "probe",
                "name": "app-responds",
                "tolerance": 200,
                "provider": {
                    "type": "http",
                    "url": "https://api.example.com/health"
                }
            }
        ]
    },
    "method": [
        {
            "type": "action",
            "name": "kill-primary-database",
            "provider": {
                "type": "python",
                "module": "chaosaws.rds.actions",
                "func": "reboot_db_instance",
                "arguments": {
                    "db_instance_identifier": "prod-primary"
                }
            }
        },
        {
            "type": "probe",
            "name": "wait-for-failover",
            "provider": {
                "type": "python",
                "module": "chaosaws.rds.probes",
                "func": "instance_status",
                "arguments": {
                    "db_instance_identifier": "prod-replica"
                }
            },
            "tolerance": "available"
        }
    ],
    "rollbacks": [
        {
            "type": "action",
            "name": "verify-recovery",
            "provider": {
                "type": "http",
                "url": "https://api.example.com/health"
            }
        }
    ]
}

# Запуск эксперимента
result = run_experiment(experiment)
print(json.dumps(result, indent=2))

# dr_test_infrastructure.tf - Настройка мульти-региональной DR-инфраструктуры

provider "aws" {
  alias  = "primary"
  region = "us-east-1"
}

provider "aws" {
  alias  = "dr"
  region = "us-west-2"
}

# Тестовое DR-окружение во вторичном регионе
resource "aws_instance" "dr_test" {
  provider      = aws.dr
  ami           = var.dr_ami_id
  instance_type = "t3.large"

  tags = {
    Name        = "dr-test-instance"
    Environment = "dr-test"
    AutoDelete  = "true"
  }

  lifecycle {
    # Предотвращение случайного воздействия на продакшен
    prevent_destroy = false
  }
}

# Lambda для автоматизированной валидации DR
resource "aws_lambda_function" "dr_validator" {
  provider      = aws.dr
  function_name = "dr-validation-test"
  runtime       = "python3.11"
  handler       = "validator.handler"
  timeout       = 900  # 15 минут

  environment {
    variables = {
      PRIMARY_REGION = "us-east-1"
      RTO_TARGET     = "3600"
      RPO_TARGET     = "900"
    }
  }
}

# Запланированный DR-тест
resource "aws_cloudwatch_event_rule" "monthly_dr_test" {
  provider            = aws.dr
  name                = "monthly-dr-test"
  schedule_expression = "cron(0 2 1 * ? *)"  # Первый день месяца в 2 ночи
}

# application_dr_test.yaml - Workflow GitHub Actions

name: DR Test

on:
  schedule:

    - cron: '0 4 * * 0'  # Еженедельно воскресенье 4 утра
  workflow_dispatch:

jobs:
  dr-test:
    runs-on: ubuntu-latest
    steps:

      - uses: actions/checkout@v4

      - name: Setup DR environment
        run: |
          # Деплой в DR-регион
          terraform -chdir=terraform/dr init
          terraform -chdir=terraform/dr apply -auto-approve

      - name: Restore from backup
        id: restore
        run: |
          START_TIME=$(date +%s)

          # Запуск восстановления из бэкапа
          aws backup start-restore-job \
            --recovery-point-arn ${{ secrets.LATEST_BACKUP_ARN }} \
            --iam-role-arn ${{ secrets.DR_ROLE_ARN }} \
            --metadata '{"targetInstanceId": "dr-test-instance"}'

          # Ожидание завершения восстановления
          while true; do
            STATUS=$(aws backup describe-restore-job --restore-job-id $JOB_ID --query 'Status' --output text)
            if [ "$STATUS" = "COMPLETED" ]; then break; fi
            if [ "$STATUS" = "FAILED" ]; then exit 1; fi
            sleep 30
          done

          END_TIME=$(date +%s)
          DURATION=$((END_TIME - START_TIME))
          echo "restore_duration=$DURATION" >> $GITHUB_OUTPUT

      - name: Validate application
        run: |
          # Запуск smoke-тестов на DR-окружении
          npm run test:smoke -- --env=dr

          # Проверка целостности данных
          npm run test:data-integrity -- --env=dr

      - name: Check RTO compliance
        run: |
          DURATION=${{ steps.restore.outputs.restore_duration }}
          RTO_TARGET=3600

          if [ $DURATION -gt $RTO_TARGET ]; then
            echo "RTO ПРЕВЫШЕН: ${DURATION}s > ${RTO_TARGET}s"
            exit 1
          fi
          echo "RTO ДОСТИГНУТ: ${DURATION}s <= ${RTO_TARGET}s"

      - name: Cleanup DR environment
        if: always()
        run: |
          terraform -chdir=terraform/dr destroy -auto-approve

# dependency_aware_restore.yaml
restore_order:

  - name: сетевая_инфраструктура
    includes: [vpc, subnets, security_groups]
    validation: connectivity_test

  - name: слой_данных
    depends_on: [сетевая_инфраструктура]
    includes: [rds, elasticache, s3]
    validation: data_integrity_test

  - name: слой_приложений
    depends_on: [слой_данных]
    includes: [ecs_services, lambda_functions]
    validation: smoke_test

  - name: слой_ingress
    depends_on: [слой_приложений]
    includes: [alb, route53]
    validation: e2e_test