Как масштабируется микросервисная архитектура

# Как масштабируется микросервисная архитектура

Концепция микросервисов

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

1. Масштабирование по горизонтали (Horizontal Scaling)

Репликация сервиса

Лоад Балансер
    ↓
  ┌─────────────────────────┐
  │  User Service (Pod 1)   │
  │  :8080                  │
  ├─────────────────────────┤
  │  User Service (Pod 2)   │
  │  :8080                  │
  ├─────────────────────────┤
  │  User Service (Pod 3)   │
  │  :8080                  │
  └─────────────────────────┘

Kubernetes Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3  # Три копии сервиса
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: myregistry/user-service:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

2. Масштабирование по вертикали (Vertical Scaling)

Увеличение ресурсов на одной машине

apiVersion: v1
kind: Pod
metadata:
  name: order-service
spec:
  containers:
  - name: order-service
    image: myregistry/order-service:1.0
    resources:
      requests:
        memory: "1Gi"
        cpu: "1"
      limits:
        memory: "2Gi"
        cpu: "2"

3. Автомасштабирование (Auto-scaling)

Kubernetes Horizontal Pod Autoscaler (HPA)

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: user-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: user-service
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

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

Spring Cloud LoadBalancer

@Configuration
public class LoadBalancerConfig {
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Service
public class OrderService {
    private final RestTemplate restTemplate;
    
    public OrderService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    public User getUser(Long userId) {
        // LoadBalancer автоматически выберет инстанс User Service
        return restTemplate.getForObject(
            "http://user-service/users/" + userId,
            User.class
        );
    }
}

Nginx Load Balancer

upstream user_service {
    server user-service-1:8080 weight=1;
    server user-service-2:8080 weight=1;
    server user-service-3:8080 weight=1;
}

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

5. Масштабирование данных (Data Scaling)

Database Sharding

@Service
public class UserShardingService {
    
    public Long getShardId(Long userId) {
        return userId % 4;  // 4 шарда
    }
    
    public User getUserFromShard(Long userId) {
        Long shardId = getShardId(userId);
        DataSource dataSource = getDataSourceForShard(shardId);
        // Запрос к шарду
        return queryUser(dataSource, userId);
    }
    
    private DataSource getDataSourceForShard(Long shardId) {
        switch (shardId.intValue()) {
            case 0: return shard0DataSource;
            case 1: return shard1DataSource;
            case 2: return shard2DataSource;
            case 3: return shard3DataSource;
            default: throw new IllegalArgumentException();
        }
    }
}

6. Кеширование (Caching)

Redis для распределённого кеша

@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public LettuceConnectionFactory connectionFactory() {
        return new LettuceConnectionFactory();
    }
    
    @Bean
    public RedisCacheManager cacheManager(LettuceConnectionFactory factory) {
        return RedisCacheManager.create(factory);
    }
}

@Service
public class UserService {
    
    @Cacheable(value = "users", key = "#userId")
    public User getUserById(Long userId) {
        // Результат кешируется в Redis
        return repository.findById(userId).orElse(null);
    }
    
    @CacheEvict(value = "users", key = "#user.id")
    public void updateUser(User user) {
        repository.save(user);
    }
}

7. Асинхронная обработка (Async Processing)

Message Queue (RabbitMQ/Kafka)

@Service
public class OrderService {
    private final RabbitTemplate rabbitTemplate;
    
    public OrderService(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }
    
    public Order createOrder(CreateOrderRequest request) {
        Order order = new Order(request);
        repository.save(order);
        
        // Асинхронно отправляем задачу обработки
        rabbitTemplate.convertAndSend(
            "orders-exchange",
            "order.created",
            order
        );
        return order;
    }
}

@Component
public class OrderProcessor {
    
    @RabbitListener(queues = "orders-queue")
    public void processOrder(Order order) {
        // Обработка заказа в отдельном потоке
        System.out.println("Обработка заказа: " + order.getId());
        // Отправка email, обновление инвентаря и т.д.
    }
}

8. Service Discovery

Spring Cloud Eureka

// Сервер
@SpringBootApplication
@EnableEurekaServer
public class DiscoveryServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(DiscoveryServerApplication.class, args);
    }
}

// Микросервис
@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

@RestController
public class UserController {
    
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return new User(id, "User " + id);
    }
}

9. Circuit Breaker (защита от каскадных отказов)

Resilience4j

@Service
public class PaymentService {
    private final RestTemplate restTemplate;
    
    @CircuitBreaker(name = "externalPaymentApi", fallbackMethod = "paymentFallback")
    public PaymentResult processPayment(Payment payment) {
        return restTemplate.postForObject(
            "http://external-payment-api/process",
            payment,
            PaymentResult.class
        );
    }
    
    public PaymentResult paymentFallback(Payment payment, Exception e) {
        System.out.println("External API недоступен, используем fallback");
        return new PaymentResult(false, "Попробуйте позже");
    }
}

10. Мониторинг и логирование (Observability)

Centralized Logging (ELK Stack)

@Service
public class OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
    
    public Order createOrder(CreateOrderRequest request) {
        logger.info("Creating order for user: {}", request.getUserId());
        try {
            Order order = new Order(request);
            repository.save(order);
            logger.info("Order created: {}", order.getId());
            return order;
        } catch (Exception e) {
            logger.error("Failed to create order for user: {}", request.getUserId(), e);
            throw e;
        }
    }
}

Metrics (Prometheus)

apiVersion: v1
kind: ServiceMonitor
metadata:
  name: user-service-monitor
spec:
  selector:
    matchLabels:
      app: user-service
  endpoints:
  - port: metrics
    interval: 30s

11. Развёртывание и обновление

Blue-Green Deployment

# Blue (текущая версия)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service-blue
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
      version: v1
  template:
    metadata:
      labels:
        app: user-service
        version: v1
    spec:
      containers:
      - name: user-service
        image: myregistry/user-service:1.0
---
# Green (новая версия)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service-green
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
      version: v2
  template:
    metadata:
      labels:
        app: user-service
        version: v2
    spec:
      containers:
      - name: user-service
        image: myregistry/user-service:2.0

12. Сетка сервисов (Service Mesh) - Istio

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: user-service
spec:
  hosts:
  - user-service
  http:
  - match:
    - uri:
        prefix: "/api/v1"
    route:
    - destination:
        host: user-service
        port:
          number: 8080
        subset: v1
      weight: 80
    - destination:
        host: user-service
        port:
          number: 8080
        subset: v2
      weight: 20

Стратегии масштабирования

Best Practices

1. Начни с мониторинга — знай узкие места
2. Масштабируй что нужно — не переусложняй архитектуру
3. Используй контейнеры — Docker + Kubernetes стандарт
4. Асинхронная обработка для длительных операций
5. Кеширование для часто запрашиваемых данных
6. Service Discovery для управления инстансами
7. Graceful shutdown — корректное завершение сервиса
8. Health checks — Kubernetes должен знать о статусе