Для чего нужна кластеризация?

# Кластеризация в Java и распределённых системах

Кластеризация — это процесс объединения нескольких независимых серверов (узлов) в единую логическую систему для повышения надежности, производительности и масштабируемости приложения.

Основное назначение кластеризации

Кластеризация нужна для:

1. Масштабируемость — распределение нагрузки на несколько серверов
2. Высокая доступность (High Availability) — продолжение работы при отказе узла
3. Отказоустойчивость (Failover) — автоматический переход на резервный узел
4. Балансировка нагрузки — равномерное распределение запросов
5. Пропускная способность — обработка большего количества одновременных запросов

Архитектура кластера

┌─────────────────────────────────────────┐
│      Load Balancer (nginx, HAProxy)    │
├─────────────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐  ┌──────────┐
│  │  Node 1  │  │  Node 2  │  │  Node 3  │
│  │ (Java)   │  │ (Java)   │  │ (Java)   │
│  └──────────┘  └──────────┘  └──────────┘
│       │              │              │
└───────┼──────────────┼──────────────┼────┐
        │              │              │    │
     ┌──────────────────────────────────┐  │
     │  Shared Data Store (Database)   │  │
     │  Replication / Synchronization  │  │
     └──────────────────────────────────┘  │
        │              │              │    │
     ┌──────────────────────────────────┐  │
     │   Cluster Coordinator (Zookeeper)│◄─┘
     └──────────────────────────────────┘

Типы кластеров

1. Stateless кластер (без состояния)

Когда каждый узел может обработать любой запрос:

public class WebServerCluster {
    // Node 1
    @GetMapping("/api/users/{id}")
    public User getUser(@PathVariable long id) {
        // Получить из общей БД
        return database.findUser(id);
    }
    
    // Node 2
    @GetMapping("/api/users/{id}")
    public User getUser(@PathVariable long id) {
        // Получить из ТОЙ ЖЕ БД
        return database.findUser(id);
    }
    // Node 3 - идентично
}

Преимущества:

• Легко добавлять/удалять узлы
• Простая балансировка нагрузки
• Не требует синхронизации состояния

2. Stateful кластер (с состоянием)

Когда узлы хранят сессии и состояние:

public class SessionCluster {
    private Map<String, SessionData> sessions = new ConcurrentHashMap<>();
    
    // Каждый узел синхронизирует свое состояние с другими
    public void updateSession(String sessionId, SessionData data) {
        sessions.put(sessionId, data);
        
        // Реплицировать на другие узлы
        replicateToCluster(sessionId, data);
    }
}

Преимущества:

• Держит пользовательские сессии
• Кэширование данных на узлах

Недостатки:

• Сложнее синхронизировать
• Медленнее добавлять/удалять узлы

Практический пример: Java приложение в кластере

Load Balancer (nginx.conf)

upstream java_cluster {
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

server {
    listen 80;
    
    location / {
        proxy_pass http://java_cluster;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Java приложение на каждом узле

@SpringBootApplication
public class ClusteredApplication {
    public static void main(String[] args) {
        SpringApplication.run(ClusteredApplication.class, args);
    }
}

@RestController
public class ApiController {
    @GetMapping("/api/data/{id}")
    public ResponseEntity<?> getData(@PathVariable long id) {
        // Получить из БД (общей для всего кластера)
        Data data = repository.findById(id);
        return ResponseEntity.ok(data);
    }
    
    @PostMapping("/api/data")
    public ResponseEntity<?> createData(@RequestBody DataRequest request) {
        Data data = new Data(request.getName());
        repository.save(data);
        
        // Уведомить остальные узлы о изменении
        clusterManager.notifyOtherNodes("data_created", data);
        
        return ResponseEntity.status(201).body(data);
    }
}

Балансировка нагрузки

Round Robin (циклическое распределение)

Запрос 1 → Node 1
Запрос 2 → Node 2
Запрос 3 → Node 3
Запрос 4 → Node 1  (снова)

Least Connections (минимум соединений)

public class LoadBalancer {
    public Node selectNode(List<Node> nodes) {
        return nodes.stream()
            .min(Comparator.comparingInt(Node::getActiveConnections))
            .orElse(null);
    }
}

IP Hash (по IP клиента)

public class LoadBalancer {
    public Node selectNode(String clientIp, List<Node> nodes) {
        int hash = clientIp.hashCode() % nodes.size();
        return nodes.get(Math.abs(hash));
    }
}

Синхронизация и репликация

Синхронное копирование (сильная согласованность)

public class Database {
    public void write(String key, Object value) {
        // Писать на все узлы одновременно
        this.localWrite(key, value);
        
        for (DatabaseNode node : cluster.getNodes()) {
            node.write(key, value);  // Блокировать до завершения
        }
    }
}

Асинхронное копирование (слабая согласованность)

public class Database {
    public void write(String key, Object value) {
        // Писать локально
        this.localWrite(key, value);
        
        // Отправить в фоне
        executor.submit(() -> {
            for (DatabaseNode node : cluster.getNodes()) {
                node.write(key, value);
            }
        });
    }
}

Координация кластера (Zookeeper)

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;

public class ClusterCoordinator {
    private CuratorFramework client;
    
    public ClusterCoordinator(String zookeeperConnection) {
        this.client = CuratorFrameworkFactory.newClient(
            zookeeperConnection,
            new ExponentialBackoffRetry(1000, 3)
        );
    }
    
    public void registerNode(String nodeId) throws Exception {
        String nodePath = "/cluster/nodes/" + nodeId;
        
        client.create()
            .creatingParentsIfNeeded()
            .ephemeral()  // Удалится при отключении
            .forPath(nodePath);
    }
    
    public List<String> getActiveNodes() throws Exception {
        return client.getChildren().forPath("/cluster/nodes");
    }
}

Failover и восстановление

Heartbeat проверка

public class HealthCheck implements Runnable {
    private List<Node> nodes;
    
    @Override
    public void run() {
        for (Node node : nodes) {
            try {
                boolean isAlive = node.ping();
                if (!isAlive) {
                    handleNodeFailure(node);
                }
            } catch (Exception e) {
                handleNodeFailure(node);
            }
        }
    }
    
    private void handleNodeFailure(Node node) {
        System.out.println("Node " + node.getId() + " is down!");
        loadBalancer.removeNode(node);
        startNodeRecovery(node);
    }
}

Преимущества и недостатки

Преимущества

✓ Высокая доступность ✓ Масштабируемость ✓ Распределение нагрузки ✓ Автоматическое восстановление ✓ Линейный рост производительности

Недостатки

✗ Сложность архитектуры ✗ Проблемы с согласованностью данных (CAP теорема) ✗ Сетевые задержки ✗ Требует дополнительной инфраструктуры ✗ Сложнее отлаживать

Когда использовать кластеризацию

Нужна кластеризация когда:

• Требуется высокая доступность (99.9%+)
• Ожидается рост нагрузки
• Критичны сбои и перезагрузки
• Требуется горизонтальное масштабирование

Может не потребоваться:

• Для небольших приложений
• Когда нагрузка низкая
• На ранних стадиях проекта

Кластеризация — ключевой компонент масштабируемых и надёжных распределённых систем.