Паттерны управления микросервисами

Управление распределенной системой микросервисов требует специальных паттернов для координации, мониторинга и обеспечения надежности.

Service Discovery

Паттерн обнаружения сервисов

class ServiceRegistry {
  private services: Map<string, ServiceInstance[]> = new Map();
  
  register(service: ServiceInstance) {
    const instances = this.services.get(service.name) || [];
    instances.push(service);
    this.services.set(service.name, instances);
    this.startHealthCheck(service);
  }
  
  discover(serviceName: string): ServiceInstance[] {
    return this.services.get(serviceName) || [];
  }
}

Circuit Breaker

Защита от каскадных сбоев

enum CircuitState { CLOSED, OPEN, HALF_OPEN }

class CircuitBreaker {
  private state = CircuitState.CLOSED;
  private failureCount = 0;
  
  async execute<T>(operation: () => Promise<T>): Promise<T> {
    if (this.state === CircuitState.OPEN) {
      throw new Error('Circuit breaker is OPEN');
    }
    
    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
}

Saga Pattern

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

class OrderSaga {
  async execute(order: Order) {
    const steps = [
      { do: () => this.reserveInventory(order), undo: () => this.releaseInventory(order) },
      { do: () => this.processPayment(order), undo: () => this.refundPayment(order) },
      { do: () => this.createShipment(order), undo: () => this.cancelShipment(order) }
    ];
    
    const completed = [];
    
    try {
      for (const step of steps) {
        await step.do();
        completed.push(step);
      }
    } catch (error) {
      for (const step of completed.reverse()) {
        await step.undo();
      }
      throw error;
    }
  }
}

API Gateway

Единая точка входа

class APIGateway {
  async handleRequest(request: Request): Promise<Response> {
    // Аутентификация
    const user = await this.authenticate(request);
    
    // Маршрутизация
    const service = this.route(request.path);
    
    // Агрегация данных
    const data = await this.aggregateData(service, request);
    
    return this.formatResponse(data);
  }
}

Health Checks

Мониторинг здоровья сервисов

class HealthChecker {
  async checkHealth(service: ServiceInstance): Promise<HealthStatus> {
    try {
      const response = await fetch(service.healthCheckUrl);
      return {
        status: response.ok ? 'healthy' : 'unhealthy',
        timestamp: new Date()
      };
    } catch (error) {
      return { status: 'unhealthy', timestamp: new Date() };
    }
  }
}

Заключение

Правильное применение паттернов управления обеспечивает надежность и масштабируемость микросервисной архитектуры.