كيفية بناء أنظمة موزعة متسامحة مع الأخطاء: أنماط Circuit Breaker و Retry و Timeout

مقدمة

في الأنظمة الموزعة، الفشل ليس احتمالاً - إنه يقين. الشبكات تنقسم، والخدمات تتعطل، وقواعد البيانات تصبح غير متاحة، وارتفاعات التأخير تحدث. السؤال ليس ما إذا كانت حالات الفشل ستحدث، بل كيف يستجيب نظامك عندما تحدث.

تشارك هذه المقالة الأنماط والممارسات لبناء أنظمة تبقى وظيفية حتى عندما تفشل المكونات.

المغالطات الثمانية للحوسبة الموزعة

قبل الغوص في الحلول، اعترف بهذه الحقائق:

1. الشبكة ليست موثوقة
2. التأخير ليس صفراً
3. عرض النطاق الترددي ليس لانهائياً
4. الشبكة ليست آمنة
5. الطوبولوجيا لا تبقى ثابتة
6. ليس هناك مسؤول واحد
7. تكلفة النقل ليست صفراً
8. الشبكة ليست متجانسة

كل قرار تصميم يجب أن يأخذ هذه الحقائق في الاعتبار.

النمط 1: قاطع الدائرة

منع حالات الفشل المتتالية بإيقاف الطلبات للخدمات الفاشلة.

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) {
      if (this.shouldAttemptReset()) {
        this.state = CircuitState.HALF_OPEN;
      } else {
        throw new CircuitOpenError('الدائرة مفتوحة');
      }
    }

    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
}

النمط 2: الحاجز (Bulkhead)

عزل حالات الفشل بتقسيم الموارد.

class BulkheadExecutor {
  private activeRequests = 0;

  constructor(
    private readonly maxConcurrent: number,
    private readonly maxQueue: number,
    private readonly queueTimeout: number
  ) {}

  async execute<T>(operation: () => Promise<T>): Promise<T> {
    if (this.activeRequests < this.maxConcurrent) {
      return this.runOperation(operation);
    }

    if (this.queue.length >= this.maxQueue) {
      throw new BulkheadFullError('قائمة انتظار الحاجز ممتلئة');
    }

    await this.waitInQueue();
    return this.runOperation(operation);
  }
}

النمط 3: إعادة المحاولة مع التراجع الأسي

التعامل مع حالات الفشل العابرة بأمان.

class RetryPolicy {
  async execute<T>(operation: () => Promise<T>): Promise<T> {
    let lastError: Error;
    
    for (let attempt = 1; attempt <= this.config.maxAttempts; attempt++) {
      try {
        return await operation();
      } catch (error) {
        lastError = error as Error;
        
        if (!this.config.retryableErrors(lastError)) {
          throw lastError;
        }
        
        if (attempt < this.config.maxAttempts) {
          const delay = this.calculateDelay(attempt);
          await this.sleep(delay);
        }
      }
    }
    
    throw lastError!;
  }

  private calculateDelay(attempt: number): number {
    // التراجع الأسي: baseDelay * 2^(attempt-1)
    const exponentialDelay = this.config.baseDelay * Math.pow(2, attempt - 1);
    const cappedDelay = Math.min(exponentialDelay, this.config.maxDelay);
    // إضافة اهتزاز لمنع تأثير القطيع المدوي
    const jitter = cappedDelay * this.config.jitterFactor * Math.random();
    return cappedDelay + jitter;
  }
}

النمط 4: المهلة الزمنية

لا تنتظر إلى ما لا نهاية أبداً.

النمط 5: التدهور الرشيق

توفير وظائف مخفضة عندما تكون الخدمة الكاملة غير متاحة.

class ProductService {
  async getProductPage(productId: string): Promise<ProductPageData> {
    // البيانات الأساسية - مطلوبة
    const product = await this.getProductWithFallback(productId);
    
    // البيانات المحسنة - اختيارية، مع بدائل
    const [relatedProducts, recommendations, reviews] = await Promise.allSettled([
      this.getRelatedProducts(productId),
      this.getRecommendations(productId),
      this.getReviews(productId)
    ]);

    return {
      product,
      relatedProducts: this.extractOrDefault(relatedProducts, []),
      recommendations: this.extractOrDefault(recommendations, []),
      reviews: this.extractOrDefault(reviews, { items: [], summary: null }),
      degraded: this.isDegraded(relatedProducts, recommendations, reviews)
    };
  }
}

الملاحظة للمرونة

لا يمكنك إصلاح ما لا يمكنك رؤيته.

هندسة الفوضى

اختبر المرونة في الإنتاج.

class ChaosMonkey {
  async maybeInjectFailure(service: string): Promise<void> {
    if (!this.enabled) return;
    
    if (Math.random() < this.failureRate) {
      const failureType = this.selectFailureType();
      
      switch (failureType) {
        case 'latency':
          await this.injectLatency(1000 + Math.random() * 4000);
          break;
        case 'error':
          throw new Error(`[الفوضى] فشل محقون لـ ${service}`);
          break;
      }
    }
  }
}

الخلاصة

بناء أنظمة موزعة مرنة يتطلب:

1. القبول بأن حالات الفشل ستحدث - صمم للفشل من البداية
2. تنفيذ طبقات متعددة من الدفاع - قواطع الدائرة والحواجز وإعادات المحاولة والمهلات
3. توفير التدهور الرشيق - بعض الوظائف أفضل من لا شيء
4. الحفاظ على الملاحظة - لا يمكنك إصلاح ما لا يمكنك رؤيته
5. اختبار المرونة بنشاط - هندسة الفوضى في الإنتاج

الهدف ليس منع كل حالات الفشل - إنه ضمان أنه عندما تحدث حالات الفشل، يتم تقليل التأثير ويكون التعافي تلقائياً.