Что такое бесперебойная работа сервиса?

Бесперебойная работа сервиса (High Availability)

Бесперебойная работа сервиса (High Availability, HA) — это архитектурный подход, обеспечивающий постоянную доступность приложения даже при сбоях компонентов или сервисов. Целью HA является минимизация времени простоя (downtime) и достижение максимального коэффициента доступности (uptime), обычно измеряемого в "nines" (99.9%, 99.99% и т.д.).

Основные концепции

Uptime (время доступности) — процент времени, в течение которого сервис работает корректно. Например, 99.9% uptime означает, что сервис может быть недоступен не более 43 минут в месяц.

Downtime (время простоя) — время, когда сервис недоступен или работает неправильно.

SLA (Service Level Agreement) — договор об уровне обслуживания, в котором указываются гарантированные показатели доступности.

Таблица "Nines"

Компоненты High Availability архитектуры

1. Резервирование (Redundancy)

Наличие нескольких копий критических компонентов:

# Архитектура с несколькими серверами
servers = [
    "server1.example.com:8000",
    "server2.example.com:8000",
    "server3.example.com:8000"
]

# Клиент пытается подключиться к каждому серверу
import requests

def get_with_fallback(endpoint: str) -> dict:
    for server in servers:
        try:
            response = requests.get(f"http://{server}{endpoint}", timeout=5)
            return response.json()
        except requests.RequestException:
            continue
    raise Exception("All servers are down")

2. Load Balancing (балансировка нагрузки)

Распределение запросов между несколькими серверами:

# Конфигурация Nginx load balancer
upstream backend {
    server server1.example.com:8000 weight=1;
    server server2.example.com:8000 weight=1;
    server server3.example.com:8000 weight=1;
}

server {
    listen 80;
    server_name api.example.com;
    
    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

3. Health Checks (проверка здоровья)

Регулярная проверка состояния сервисов:

import requests
import time
from typing import List

class HealthChecker:
    def __init__(self, servers: List[str], check_interval: int = 30):
        self.servers = servers
        self.check_interval = check_interval
        self.healthy_servers = set(servers)
    
    def check_health(self, server: str) -> bool:
        try:
            response = requests.get(
                f"http://{server}/health",
                timeout=5
            )
            return response.status_code == 200
        except requests.RequestException:
            return False
    
    def run_health_checks(self):
        while True:
            healthy = set()
            for server in self.servers:
                if self.check_health(server):
                    healthy.add(server)
            
            # Уведомляем об изменениях
            if healthy != self.healthy_servers:
                print(f"Health status changed: {healthy}")
                self.healthy_servers = healthy
            
            time.sleep(self.check_interval)

# Использование
checker = HealthChecker([
    "server1.example.com:8000",
    "server2.example.com:8000",
    "server3.example.com:8000"
])

4. Failover (переход на резервную систему)

Автоматический переход на рабочий сервер при сбое:

class DatabaseConnection:
    def __init__(self, primary: str, replica: str):
        self.primary = primary
        self.replica = replica
        self.current = primary
    
    def execute_query(self, query: str):
        try:
            # Пытаемся выполнить на основной БД
            return self._query_server(self.current, query)
        except Exception as e:
            print(f"Failed on {self.current}: {e}")
            # Переходим на резервную
            self.current = self.replica if self.current == self.primary else self.primary
            return self._query_server(self.current, query)
    
    def _query_server(self, server: str, query: str):
        # Реальное выполнение запроса
        pass

5. Репликация данных (Data Replication)

Синхронизация данных между несколькими узлами:

# Master-Slave репликация в PostgreSQL
# На master сервере
wal_level = replica
max_wal_senders = 3
max_replication_slots = 3

# На slave сервере создаём replication slot
SELECT * FROM pg_create_physical_replication_slot('replica_slot');

# Запускаем репликацию
pg_basebackup -h master_ip -D /var/lib/postgresql/data -U replicator -v -P

Паттерны High Availability для микросервисов

Circuit Breaker (автоматический выключатель)

from enum import Enum
from datetime import datetime, timedelta

class CircuitState(Enum):
    CLOSED = "closed"      # Нормальное состояние
    OPEN = "open"          # Не пропускаем запросы
    HALF_OPEN = "half_open"  # Тестируем восстановление

class CircuitBreaker:
    def __init__(self, failure_threshold: int = 5, timeout: int = 60):
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.state = CircuitState.CLOSED
        self.failure_count = 0
        self.last_failure_time = None
    
    def call(self, func, *args, **kwargs):
        if self.state == CircuitState.OPEN:
            if datetime.now() - self.last_failure_time > timedelta(seconds=self.timeout):
                self.state = CircuitState.HALF_OPEN
                self.failure_count = 0
            else:
                raise Exception("Circuit breaker is OPEN")
        
        try:
            result = func(*args, **kwargs)
            self._on_success()
            return result
        except Exception as e:
            self._on_failure()
            raise e
    
    def _on_success(self):
        self.failure_count = 0
        self.state = CircuitState.CLOSED
    
    def _on_failure(self):
        self.failure_count += 1
        self.last_failure_time = datetime.now()
        if self.failure_count >= self.failure_threshold:
            self.state = CircuitState.OPEN

# Использование
breaker = CircuitBreaker(failure_threshold=5, timeout=60)

def call_external_service():
    return breaker.call(requests.get, "https://api.example.com/data")

Стратегии для High Availability

1. Active-Active — несколько экземпляров работают одновременно
2. Active-Passive — основной работает, резервный стоит в ожидании
3. Multi-Region — сервисы в разных географических регионах
4. Database Clustering — несколько БД синхронизированы

Мониторинг и алертинг

from prometheus_client import Counter, Gauge, start_http_server
import time

# Метрики
request_count = Counter('requests_total', 'Total requests')
error_count = Counter('errors_total', 'Total errors')
uptime_gauge = Gauge('uptime_seconds', 'Uptime in seconds')

start_time = time.time()

def update_uptime():
    uptime_gauge.set(time.time() - start_time)

def handle_request():
    request_count.inc()
    try:
        # Обработка
        pass
    except Exception:
        error_count.inc()

# Запускаем HTTP сервер для метрик
start_http_server(8000)

Лучшие практики

1. Планируйте на сбой — предполагайте, что компоненты будут падать
2. Тестируйте failover — регулярно проверяйте механизмы резервирования
3. Мониторьте всё — используйте метрики и логи для раннего обнаружения проблем
4. Документируйте процессы — создавайте playbook'и для recovery
5. Используйте разные слои — redundancy на каждом уровне (load balancer, app, БД)

Бесперебойная работа сервиса требует тщательного проектирования, но является критически важной для production систем.