PrepBro
← Назад к вопросам

Что нужно учитывать при кластеризации?

2.4 Senior🔥 141 комментариев
#Docker, Kubernetes и DevOps

Комментарии (1)

🐱
claude-haiku-4.5PrepBro AI23 мар. 2026 г.(ред.)

Ответ сгенерирован нейросетью и может содержать ошибки

Кластеризация: ключевые аспекты при развёртывании системы

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

1. Состояние приложения (Stateless vs Stateful)

Одно из самых важных решений — сделать приложение stateless или stateful.

// ❌ STATEFUL — приложение хранит состояние
@RestController
public class CartController {
    // Состояние в памяти приложения — проблема при кластеризации!
    private Map<String, CartData> userCarts = new HashMap<>();
    
    @PostMapping("/add-to-cart")
    public void addToCart(String userId, String productId) {
        CartData cart = userCarts.computeIfAbsent(userId, k -> new CartData());
        cart.addProduct(productId);
    }
    
    @GetMapping("/cart")
    public CartData getCart(String userId) {
        return userCarts.get(userId); // Проблема: если запрос попадёт на другой сервер, данных не будет!
    }
}

// ✅ STATELESS — состояние в БД или session store
@RestController
public class CartController {
    private final CartService cartService;
    private final SessionStore sessionStore;
    
    public CartController(CartService cartService, SessionStore sessionStore) {
        this.cartService = cartService;
        this.sessionStore = sessionStore;
    }
    
    @PostMapping("/add-to-cart")
    public void addToCart(String userId, String productId) {
        // Данные сохраняются в БД, доступны всем узлам кластера
        cartService.addToCart(userId, productId);
    }
    
    @GetMapping("/cart")
    public CartData getCart(String userId) {
        // Получаем из БД — работает независимо от того, какой узел обработает запрос
        return cartService.getCart(userId);
    }
}

2. Управление сессиями

При кластеризации сессии нельзя хранить только в памяти одного сервера.

// Варианты хранения сессий:

// 1. Spring Session + Redis (рекомендуется)
@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 3600)
public class SessionConfig {
    // Сессии автоматически сохраняются в Redis
    // Доступны всем узлам кластера
}

// 2. Sticky sessions (менее надёжно)
// Балансировщик нагрузки всегда отправляет запросы одного пользователя на один сервер
// Проблема: если сервер упадёт, сессия потеряется

// 3. Spring Session + JDBC (для БД)
@Configuration
@EnableJdbcHttpSession(maxInactiveIntervalInSeconds = 3600)
public class JdbcSessionConfig {
    // Сессии хранятся в таблице БД
    // Медленнее чем Redis, но всегда доступны
}

3. Балансирование нагрузки (Load Balancing)

При кластеризации нужен балансировщик нагрузки, который распределяет запросы между узлами.

Клиент
   ↓
┌─────────────────────────────┐
│   Load Balancer (Nginx)     │
│   - Round Robin             │
│   - Least Connections       │
│   - IP Hash                 │
└─────────────────────────────┘
   ↓        ↓        ↓
┌────────┐ ┌────────┐ ┌────────┐
│Node 1  │ │Node 2  │ │Node 3  │
│:8080   │ │:8080   │ │:8080   │
└────────┘ └────────┘ └────────┘

# Пример конфигурации Nginx
upstream backend {
    server localhost:8080 weight=1;
    server localhost:8081 weight=1;
    server localhost:8082 weight=1;
}

server {
    listen 80;
    location / {
        proxy_pass http://backend;
    }
}

4. Синхронизация данных

Используемые подходы для синхронизации:

// 1. Общая база данных (рекомендуется)
// Все узлы читают/пишут в одну БД
// Проблема: БД становится узким местом

public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}

// 2. Кеш (Redis, Memcached)
@Service
public class UserService {
    private final UserRepository userRepository;
    private final RedisTemplate<String, User> redisTemplate;
    
    public User getUser(Long id) {
        // Кеш первого уровня — Redis
        User cachedUser = redisTemplate.opsForValue().get("user:" + id);
        if (cachedUser != null) {
            return cachedUser;
        }
        
        // Если в кеше не найдено — в БД
        User user = userRepository.findById(id).orElse(null);
        if (user != null) {
            redisTemplate.opsForValue().set("user:" + id, user, Duration.ofHours(1));
        }
        
        return user;
    }
    
    // При обновлении инвалидировать кеш
    public void updateUser(User user) {
        userRepository.save(user);
        redisTemplate.delete("user:" + user.getId()); // Очистить кеш
    }
}

// 3. Message Queue (асинхронная синхронизация)
@Service
public class EventPublisher {
    private final KafkaTemplate<String, UserEvent> kafkaTemplate;
    
    public void publishUserUpdate(User user) {
        UserEvent event = new UserEvent("USER_UPDATED", user);
        kafkaTemplate.send("user-events", event);
    }
}

@Service
public class EventSubscriber {
    private final UserService userService;
    
    @KafkaListener(topics = "user-events")
    public void handleUserEvent(UserEvent event) {
        // Обновить локальный кеш или состояние
        userService.invalidateCache(event.getUser().getId());
    }
}

5. Распределённые транзакции

При работе с несколькими БД или сервисами используй паттерны:

// Паттерн Saga (рекомендуется)
@Service
public class OrderSaga {
    private final OrderService orderService;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    @Transactional
    public void createOrder(Order order) throws Exception {
        try {
            // Шаг 1: Зарезервировать товары
            inventoryService.reserve(order.getItems());
            
            // Шаг 2: Обработать платёж
            paymentService.process(order.getPayment());
            
            // Шаг 3: Создать заказ
            orderService.create(order);
            
        } catch (PaymentException e) {
            // Откатить резервирование
            inventoryService.unreserve(order.getItems());
            throw e;
        }
    }
}

// Two-Phase Commit (менее рекомендуется — сложно и медленно)
// Prepare фаза (vote) → Commit фаза (execute)

6. Отказоустойчивость и мониторинг

// Health checks
@RestController
public class HealthController {
    @GetMapping("/health")
    public ResponseEntity<HealthStatus> health() {
        boolean dbOk = checkDatabase();
        boolean cacheOk = checkCache();
        
        if (dbOk && cacheOk) {
            return ResponseEntity.ok(new HealthStatus("UP"));
        } else {
            return ResponseEntity.status(500).body(new HealthStatus("DOWN"));
        }
    }
}

// Circuit Breaker
@Service
public class ExternalApiService {
    private final RestTemplate restTemplate;
    private CircuitBreaker circuitBreaker = new CircuitBreaker(3, 60000);
    
    public String callExternalApi() throws Exception {
        if (circuitBreaker.isOpen()) {
            // API недоступна, возвращаем cached данные или default
            return "Cached response";
        }
        
        try {
            return restTemplate.getForObject("https://api.example.com", String.class);
        } catch (Exception e) {
            circuitBreaker.recordFailure();
            throw e;
        }
    }
}

// Retry mechanism
@Service
public class ResilientService {
    @Retry(maxAttempts = 3, delay = 1000)
    public void unreliableOperation() {
        // Автоматический retry при ошибке
    }
}

7. Масштабирование БД

// Шардирование (Sharding)
// Разделить данные по ключу (например, по userId)

public class ShardSelector {
    private static final int SHARD_COUNT = 10;
    
    public int selectShard(Long userId) {
        return (int) (userId % SHARD_COUNT);
    }
    
    public DataSource getDataSource(Long userId) {
        int shard = selectShard(userId);
        return shardDataSources.get(shard);
    }
}

// Read replicas
// Master → хранит все данные
// Replicas → копии для чтения

@Service
public class UserService {
    @Autowired(required = false)
    @Qualifier("master")
    private UserRepository masterRepository; // для write
    
    @Autowired(required = false)
    @Qualifier("replica")
    private UserRepository replicaRepository; // для read
    
    public User getUser(Long id) {
        // Читаем из replicas (можно параллелизировать)
        return replicaRepository.findById(id).orElse(null);
    }
    
    public void updateUser(User user) {
        // Пишем только в master
        masterRepository.save(user);
    }
}

8. Конфигурация и развёртывание

// Конфигурация чувствительна к окружению
@Configuration
@Profile("production")
public class ProductionConfig {
    @Bean
    public DataSource dataSource() {
        // Используем connection pooling
        HikariConfig config = new HikariConfig();
        config.setMaximumPoolSize(20);
        config.setMinimumIdle(5);
        return new HikariDataSource(config);
    }
}

// Environment variables вместо hardcode
@Component
public class AppProperties {
    @Value("${app.cache.ttl:3600}")
    private int cacheTtl;
    
    @Value("${spring.datasource.url}")
    private String dbUrl;
}

Итоговый чек-лист

  • Приложение должно быть stateless или использовать external session store
  • Используй Load Balancer для распределения трафика
  • Выбери стратегию синхронизации данных (общая БД, кеш, message queue)
  • Обработай распределённые транзакции (Saga паттерн)
  • Настрой health checks и monitoring
  • Используй Circuit Breaker для обработки ошибок
  • Масштабируй БД (read replicas, sharding)
  • Конфигурируй приложение через environment variables
  • Логируй и мониторь все узлы кластера централизованно