Какие знаешь проблемы при масштабировании сервисов?

Проблемы при масштабировании сервисов

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

Проблемы уровня приложения

1. Неэффективные запросы к БД

Когда растёт нагрузка, плохие SQL-запросы становятся узким местом:

// Плохо: N+1 problem
public List<User> getUsersWithOrders() {
    List<User> users = db.query("SELECT * FROM users");
    for (User user : users) {
        user.setOrders(db.query("SELECT * FROM orders WHERE user_id = ?", user.getId()));
    }
    return users;
}

// Хорошо: JOIN
public List<User> getUsersWithOrders() {
    return db.query("SELECT u.*, o.* FROM users u LEFT JOIN orders o ON u.id = o.user_id");
}

2. Отсутствие кэширования

В памяти приложения (local cache):

private Map<Long, User> cache = new ConcurrentHashMap<>();

public User getUser(Long id) {
    return cache.computeIfAbsent(id, k -> db.findUser(k));
}

Распределённое кэширование (Redis, Memcached):

@Cacheable(value = "users", key = "#id")
public User getUser(Long id) {
    return db.findUser(id);
}

3. Синхронная обработка

Проблема: дорогие операции блокируют поток, ограничивая throughput.

// Плохо: синхронный поход
@PostMapping("/order")
public OrderResponse createOrder(@RequestBody Order order) {
    Order saved = orderService.save(order);
    emailService.sendConfirmation(order);
    paymentService.processPayment(order);
    return new OrderResponse(saved);
}

// Хорошо: асинхронная обработка
@PostMapping("/order")
public OrderResponse createOrder(@RequestBody Order order) {
    Order saved = orderService.save(order);
    emailQueue.send(new EmailTask(order));
    paymentQueue.send(new PaymentTask(order));
    return new OrderResponse(saved);
}

4. Утечки памяти

// Плохо: статический список растет бесконечно
private static List<User> activeUsers = new ArrayList<>();

public void onUserLogin(User user) {
    activeUsers.add(user);
}

// Хорошо: слабые ссылки
private Map<Long, User> activeUsers = new WeakHashMap<>();

Проблемы уровня архитектуры

1. Монолитная архитектура

Единое приложение становится точкой отказа. Решение: микросервисы

Монолит:
├── User Service
├── Order Service
├── Payment Service
└── Notification Service

Микросервисы:
У каждого - независимое масштабирование

2. Неправильное разделение данных

Шардирование распределяет данные по нескольким БД:

public class UserShardingStrategy {
    private List<Database> shards;
    
    public Database getShardForUser(Long userId) {
        return shards.get((int)(userId % shards.size()));
    }
}

3. Неправильная обработка состояния (stateful сервисы)

Проблема: состояние в памяти приложения не масштабируется.

// Плохо: состояние в памяти
private Map<String, WebSocketSession> sessions = new HashMap<>();

// Хорошо: состояние в Redis
private RedisTemplate<String, String> redis;

public void addSession(String userId, String sessionId) {
    redis.opsForValue().set("session:" + userId, sessionId, Duration.ofHours(1));
}

Проблемы инфраструктуры

1. Connection pooling исчерпан

@Configuration
public class DataSourceConfig {
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setMaximumPoolSize(20);
        config.setMinimumIdle(5);
        config.setConnectionTimeout(10000);
        return new HikariDataSource(config);
    }
}

2. Недостаточно реплик для чтения

@Service
public class UserService {
    @Transactional(readOnly = true)
    public User getUser(Long id) {
        return userRepository.findById(id);
    }
    
    @Transactional
    public void updateUser(User user) {
        userRepository.save(user);
    }
}

3. Отсутствие load balancing

Распределяем нагрузку с помощью Nginx, HAProxy:

upstream backend {
    server app1:8080;
    server app2:8080;
    server app3:8080;
}

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

Проблемы отказоустойчивости

1. Отсутствие circuit breaker

@CircuitBreaker(name = "userService", fallbackMethod = "getDefaultUser")
public UserDto getUser(Long id) {
    return restTemplate.getForObject("http://user-service/" + id, UserDto.class);
}

public UserDto getDefaultUser(Long id, Exception ex) {
    return new UserDto(id, "Unknown User");
}

2. Отсутствие retry механизма

@Retry(maxAttempts = 3, delay = 1000)
public void processPayment(Payment payment) {
    paymentGateway.process(payment);
}

Практические советы для масштабирования

• Профилируй — найди реальные bottleneck'и
• Кэшируй — Redis, Memcached, local cache
• Асинхронизируй — RabbitMQ, Kafka
• Шардируй данные при необходимости
• Мониторь — Prometheus, ELK, Jaeger
• Разбей на микросервисы только когда будешь готов
• Оптимизируй БД — индексы, explain plans, read replicas
• Используй масштабируемые стеки — Spring Cloud, Kubernetes

Масштабирование — это про системное мышление и постоянную оптимизацию.