مدار شکن پایتون: ساخت برنامه‌های تحمل‌پذیر در برابر خطا و مقاوم

در دنیای توسعه نرم‌افزار، به ویژه هنگام کار با سیستم‌های توزیع شده و میکروسرویس‌ها، برنامه‌ها ذاتاً مستعد خطا هستند. این خطاها می‌توانند از منابع مختلفی ناشی شوند، از جمله مشکلات شبکه، قطعی‌های موقت سرویس و منابع بیش از حد بارگذاری شده. بدون مدیریت صحیح، این خطاها می‌توانند در سراسر سیستم گسترش یابند و منجر به از کار افتادن کامل و تجربه کاربری ضعیف شوند. اینجاست که الگوی مدار شکن وارد می‌شود – یک الگوی طراحی حیاتی برای ساخت برنامه‌های تحمل‌پذیر در برابر خطا و مقاوم.

درک تحمل‌پذیری در برابر خطا و مقاومت

قبل از پرداختن به الگوی مدار شکن، درک مفاهیم تحمل‌پذیری در برابر خطا و مقاومت ضروری است:

• تحمل‌پذیری در برابر خطا: توانایی یک سیستم برای ادامه عملکرد صحیح حتی در حضور خطاها. این امر در جهت به حداقل رساندن تأثیر خطاها و اطمینان از عملکردی بودن سیستم است.
• مقاومت: توانایی یک سیستم برای بازیابی از خطاها و سازگاری با شرایط متغیر. این امر در جهت برگشت از خطاها و حفظ سطح بالایی از عملکرد است.

الگوی مدار شکن یک جزء کلیدی در دستیابی به هر دو مورد تحمل‌پذیری در برابر خطا و مقاومت است.

الگوی مدار شکن توضیح داده شده است

الگوی مدار شکن یک الگوی طراحی نرم‌افزار است که برای جلوگیری از شکست‌های آبشاری در سیستم‌های توزیع شده استفاده می‌شود. این الگو به عنوان یک لایه محافظ عمل می‌کند، سلامت سرویس‌های راه دور را نظارت می‌کند و از تلاش مکرر برنامه برای عملیاتی که احتمال شکست آن‌ها وجود دارد، جلوگیری می‌کند. این امر برای جلوگیری از اتمام منابع و اطمینان از پایداری کلی سیستم حیاتی است.

مانند یک مدار شکن الکتریکی در خانه خود فکر کنید. هنگامی که خطایی رخ می‌دهد (به عنوان مثال، اتصال کوتاه)، مدار شکن قطع می‌شود و از جریان برق جلوگیری می‌کند و از آسیب بیشتر جلوگیری می‌کند. به طور مشابه، مدار شکن تماس‌ها با سرویس‌های راه دور را نظارت می‌کند. اگر تماس‌ها مکرراً با شکست مواجه شوند، مدار شکن «قطع» می‌شود و از تماس‌های بیشتر با آن سرویس جلوگیری می‌کند تا زمانی که سرویس دوباره سالم تشخیص داده شود.

وضعیت‌های مدار شکن

مدار شکن معمولاً در سه وضعیت عمل می‌کند:

• بسته (Closed): وضعیت پیش‌فرض. مدار شکن اجازه می‌دهد درخواست‌ها به سرویس راه دور عبور کنند. این الگو موفقیت یا شکست این درخواست‌ها را نظارت می‌کند. اگر تعداد خطاها در یک پنجره زمانی مشخص از یک آستانه از پیش تعریف شده تجاوز کند، مدار شکن به وضعیت «باز» (Open) تغییر وضعیت می‌دهد.
• باز (Open): در این وضعیت، مدار شکن بلافاصله تمام درخواست‌ها را رد می‌کند و بدون تلاش برای تماس با سرویس راه دور، یک خطا (به عنوان مثال، `CircuitBreakerError`) را به برنامه فراخوان باز می‌گرداند. پس از یک دوره زمانی از پیش تعریف شده، مدار شکن به وضعیت «نیمه باز» (Half-Open) تغییر وضعیت می‌دهد.
• نیمه باز (Half-Open): در این وضعیت، مدار شکن اجازه می‌دهد تا تعداد محدودی درخواست به سرویس راه دور عبور کند. این کار برای آزمایش اینکه آیا سرویس بازیابی شده است انجام می‌شود. اگر این درخواست‌ها موفقیت‌آمیز باشند، مدار شکن به وضعیت «بسته» باز می‌گردد. اگر با شکست مواجه شوند، به وضعیت «باز» باز می‌گردد.

مزایای استفاده از مدار شکن

• بهبود تحمل‌پذیری در برابر خطا: با ایزوله کردن سرویس‌های معیوب از شکست‌های آبشاری جلوگیری می‌کند.
• افزایش مقاومت: به سیستم اجازه می‌دهد تا به طور مطلوب از خطاها بازیابی شود.
• کاهش مصرف منابع: از اتلاف منابع برای درخواست‌های ناموفق مکرر جلوگیری می‌کند.
• تجربه کاربری بهتر: از زمان‌های انتظار طولانی و برنامه‌های غیرپاسخگو جلوگیری می‌کند.
• مدیریت خطای ساده‌تر: روشی سازگار برای مدیریت خطاها ارائه می‌دهد.

پیاده‌سازی مدار شکن در پایتون

بیایید بررسی کنیم که چگونه الگوی مدار شکن را در پایتون پیاده‌سازی کنیم. با یک پیاده‌سازی پایه شروع می‌کنیم و سپس ویژگی‌های پیشرفته‌تری مانند آستانه‌های شکست و دوره‌های زمانی را اضافه خواهیم کرد.

پیاده‌سازی پایه

در اینجا یک مثال ساده از کلاس مدار شکن آورده شده است:

            
import time

class CircuitBreaker:
 def __init__(self, service_function, failure_threshold=3, retry_timeout=10):
 self.service_function = service_function
 self.failure_threshold = failure_threshold
 self.retry_timeout = retry_timeout
 self.state = 'closed'
 self.failure_count = 0
 self.last_failure_time = None

 def __call__(self, *args, **kwargs):
 if self.state == 'open':
 if time.time() - self.last_failure_time < self.retry_timeout:
 raise Exception('Circuit is open')
 else:
 self.state = 'half-open'

 if self.state == 'half_open':
 try:
 result = self.service_function(*args, **kwargs)
 self.state = 'closed'
 self.failure_count = 0
 return result
 except Exception as e:
 self.failure_count += 1
 self.last_failure_time = time.time()
 self.state = 'open'
 raise e

 if self.state == 'closed':
 try:
 result = self.service_function(*args, **kwargs)
 self.failure_count = 0
 return result
 except Exception as e:
 self.failure_count += 1
 if self.failure_count >= self.failure_threshold:
 self.state = 'open'
 self.last_failure_time = time.time()
 raise Exception('Circuit is open') from e
 raise e

            

              
                Copy
              
            
          

توضیح:

• `__init__`: مدار شکن را با تابع سرویس برای فراخوانی، یک آستانه شکست و یک زمان تلاش مجدد مقداردهی اولیه می‌کند.
• `__call__`: این روش تماس‌ها با تابع سرویس را رهگیری کرده و منطق مدار شکن را مدیریت می‌کند.
• وضعیت بسته (Closed): تابع سرویس را فراخوانی می‌کند. اگر با شکست مواجه شود، `failure_count` را افزایش می‌دهد. اگر `failure_count` از `failure_threshold` بیشتر شود، به وضعیت «باز» (Open) تغییر وضعیت می‌دهد.
• وضعیت باز (Open): بلافاصله یک استثنا ایجاد می‌کند و از تماس‌های بیشتر با سرویس جلوگیری می‌کند. پس از `retry_timeout`، به وضعیت «نیمه باز» (Half-Open) تغییر وضعیت می‌دهد.
• وضعیت نیمه باز (Half-Open): اجازه می‌دهد یک تماس تستی به سرویس انجام شود. اگر موفقیت‌آمیز باشد، مدار شکن به وضعیت «بسته» بازمی‌گردد. اگر با شکست مواجه شود، به وضعیت «باز» بازمی‌گردد.

مثال استفاده

بیایید نحوه استفاده از این مدار شکن را نشان دهیم:

            
import time
import random

def my_service(success_rate=0.8):
 if random.random() < success_rate:
 return "Success!"
 else:
 raise Exception("Service failed")


circuit_breaker = CircuitBreaker(my_service, failure_threshold=2, retry_timeout=5)

for i in range(10):
 try:
 result = circuit_breaker()
 print(f"Attempt {i+1}: {result}")
 except Exception as e:
 print(f"Attempt {i+1}: Error: {e}")
 time.sleep(1)

            

              
                Copy
              
            
          

در این مثال، `my_service` سرویسی را شبیه‌سازی می‌کند که گاهی اوقات با شکست مواجه می‌شود. مدار شکن سرویس را نظارت می‌کند و پس از تعداد مشخصی شکست، مدار را «باز» می‌کند و از تماس‌های بیشتر جلوگیری می‌کند. پس از یک دوره زمانی، به «نیمه باز» تغییر وضعیت می‌دهد تا سرویس را دوباره آزمایش کند.

افزودن ویژگی‌های پیشرفته

پیاده‌سازی پایه را می‌توان برای شامل کردن ویژگی‌های پیشرفته‌تر گسترش داد:

• زمان‌بندی برای تماس‌های سرویس: پیاده‌سازی یک مکانیزم زمان‌بندی برای جلوگیری از گیر کردن مدار شکن در صورتی که سرویس برای پاسخگویی بیش از حد طول بکشد.
• نظارت و ثبت وقایع: انتقال وضعیت و خطاها را برای نظارت و اشکال‌زدایی ثبت کنید.
• متریک‌ها و گزارش‌دهی: متریک‌هایی در مورد عملکرد مدار شکن (به عنوان مثال، تعداد تماس‌ها، خطاها، زمان باز بودن) جمع‌آوری کرده و آن‌ها را به یک سیستم نظارتی گزارش دهید.
• پیکربندی: اجازه پیکربندی آستانه شکست، زمان تلاش مجدد و سایر پارامترها را از طریق فایل‌های پیکربندی یا متغیرهای محیطی بدهید.

پیاده‌سازی بهبود یافته با زمان‌بندی و ثبت وقایع

در اینجا یک نسخه اصلاح شده است که شامل زمان‌بندی و ثبت وقایع پایه است:

            
import time
import logging
import functools

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class CircuitBreaker:
 def __init__(self, service_function, failure_threshold=3, retry_timeout=10, timeout=5):
 self.service_function = service_function
 self.failure_threshold = failure_threshold
 self.retry_timeout = retry_timeout
 self.timeout = timeout
 self.state = 'closed'
 self.failure_count = 0
 self.last_failure_time = None
 self.logger = logging.getLogger(__name__)

 @staticmethod
 def _timeout(func, timeout): #Decorator
 @functools.wraps(func)
 def wrapper(*args, **kwargs):
 import signal

 def handler(signum, frame):
 raise TimeoutError("Function call timed out")

 signal.signal(signal.SIGALRM, handler)
 signal.alarm(timeout)
 try:
 result = func(*args, **kwargs)
 signal.alarm(0)
 return result
 except TimeoutError:
 raise
 except Exception as e:
 raise
 finally:
 signal.alarm(0)
 return wrapper


 def __call__(self, *args, **kwargs):
 if self.state == 'open':
 if time.time() - self.last_failure_time < self.retry_timeout:
 self.logger.warning('Circuit is open, rejecting request')
 raise Exception('Circuit is open')
 else:
 self.logger.info('Circuit is half-open')
 self.state = 'half_open'

 if self.state == 'half_open':
 try:
 result = self._timeout(self.service_function, self.timeout)(*args, **kwargs)
 self.logger.info('Circuit is closed after successful half-open call')
 self.state = 'closed'
 self.failure_count = 0
 return result
 except TimeoutError as e:
 self.failure_count += 1
 self.last_failure_time = time.time()
 self.logger.error(f'Half-open call timed out: {e}')
 self.state = 'open'
 raise e
 except Exception as e:
 self.failure_count += 1
 self.last_failure_time = time.time()
 self.logger.error(f'Half-open call failed: {e}')
 self.state = 'open'
 raise e

 if self.state == 'closed':
 try:
 result = self._timeout(self.service_function, self.timeout)(*args, **kwargs)
 self.failure_count = 0
 return result
 except TimeoutError as e:
 self.failure_count += 1
 if self.failure_count >= self.failure_threshold:
 self.logger.error(f'Service timed out repeatedly, opening circuit: {e}')
 self.state = 'open'
 self.last_failure_time = time.time()
 raise Exception('Circuit is open') from e
 self.logger.error(f'Service timed out: {e}')
 raise e
 except Exception as e:
 self.failure_count += 1
 if self.failure_count >= self.failure_threshold:
 self.logger.error(f'Service failed repeatedly, opening circuit: {e}')
 self.state = 'open'
 self.last_failure_time = time.time()
 raise Exception('Circuit is open') from e
 self.logger.error(f'Service failed: {e}')
 raise e

            

              
                Copy
              
            
          

بهبودهای کلیدی:

• زمان‌بندی: با استفاده از ماژول `signal` برای محدود کردن زمان اجرای تابع سرویس پیاده‌سازی شده است.
• ثبت وقایع: از ماژول `logging` برای ثبت انتقال وضعیت، خطاها و هشدارها استفاده می‌کند. این امر نظارت بر رفتار مدار شکن را آسان‌تر می‌کند.
• دکوراتور: پیاده‌سازی زمان‌بندی اکنون از یک دکوراتور برای کد تمیزتر و کاربرد گسترده‌تر استفاده می‌کند.

مثال استفاده (با زمان‌بندی و ثبت وقایع)

            
import time
import random

def my_service(success_rate=0.8):
 time.sleep(random.uniform(0, 3))
 if random.random() < success_rate:
 return "Success!"
 else:
 raise Exception("Service failed")

circuit_breaker = CircuitBreaker(my_service, failure_threshold=2, retry_timeout=5, timeout=2)

for i in range(10):
 try:
 result = circuit_breaker()
 print(f"Attempt {i+1}: {result}")
 except Exception as e:
 print(f"Attempt {i+1}: Error: {e}")
 time.sleep(1)

            

              
                Copy
              
            
          

افزودن زمان‌بندی و ثبت وقایع، استحکام و قابلیت مشاهده مدار شکن را به طور قابل توجهی بهبود می‌بخشد.

انتخاب پیاده‌سازی مناسب مدار شکن

در حالی که مثال‌های ارائه شده نقطه شروعی را ارائه می‌دهند، ممکن است بخواهید از کتابخانه‌ها یا فریم‌ورک‌های موجود پایتون برای محیط‌های تولیدی استفاده کنید. برخی از گزینه‌های محبوب عبارتند از:

• Pybreaker: یک کتابخانه پرکاربرد و غنی از ویژگی که پیاده‌سازی قوی مدار شکن را ارائه می‌دهد. این کتابخانه از پیکربندی‌های مختلف، متریک‌ها و انتقال وضعیت پشتیبانی می‌کند.
• Resilience4j (با پوشش پایتون): در حالی که Resilience4j عمدتاً یک کتابخانه جاوا است، قابلیت‌های جامع تحمل‌پذیری در برابر خطا از جمله مدار شکن‌ها را ارائه می‌دهد. می‌توان از یک پوشش پایتون برای ادغام استفاده کرد.
• پیاده‌سازی‌های سفارشی: برای نیازهای خاص یا سناریوهای پیچیده، ممکن است یک پیاده‌سازی سفارشی ضروری باشد که کنترل کاملی بر رفتار مدار شکن و ادغام با سیستم‌های نظارتی و ثبت وقایع برنامه را فراهم کند.

بهترین شیوه‌های مدار شکن

برای استفاده مؤثر از الگوی مدار شکن، این بهترین شیوه‌ها را دنبال کنید:

• انتخاب آستانه شکست مناسب: آستانه شکست باید بر اساس نرخ خطای مورد انتظار سرویس راه دور به دقت انتخاب شود. تنظیم آستانه خیلی پایین می‌تواند منجر به شکست‌های غیرضروری مدار شود، در حالی که تنظیم آن خیلی بالا ممکن است تشخیص خطاهای واقعی را به تأخیر بیندازد. نرخ شکست معمول را در نظر بگیرید.
• تنظیم زمان تلاش مجدد واقع‌بینانه: زمان تلاش مجدد باید به اندازه کافی طولانی باشد تا به سرویس راه دور فرصت بازیابی داده شود، اما نه آنقدر طولانی که باعث تأخیر بیش از حد برای برنامه فراخوان شود. تأخیر شبکه و زمان بازیابی سرویس را در نظر بگیرید.
• پیاده‌سازی نظارت و هشدار: انتقال وضعیت، نرخ خطا و مدت زمان باز بودن مدار شکن را نظارت کنید. هشدارهایی را برای اطلاع‌رسانی در صورت باز یا بسته شدن مکرر مدار شکن یا افزایش نرخ خطا تنظیم کنید. این امر برای مدیریت فعال حیاتی است.
• پیکربندی مدار شکن‌ها بر اساس وابستگی‌های سرویس: مدار شکن‌ها را بر روی سرویس‌هایی که وابستگی‌های خارجی دارند یا برای عملکرد برنامه حیاتی هستند، اعمال کنید. اولویت حفاظت از سرویس‌های حیاتی را در نظر بگیرید.
• مدیریت صحیح خطاهای مدار شکن: برنامه شما باید بتواند استثنائات `CircuitBreakerError` را به طور مطلوب مدیریت کند و پاسخ‌های جایگزین یا مکانیزم‌های بازگشتی را به کاربر ارائه دهد. برای کاهش تدریجی طراحی کنید.
• در نظر گرفتن ایده‌پوتنس (Idempotency): اطمینان حاصل کنید که عملیات انجام شده توسط برنامه شما ایده‌پوتنت هستند، به خصوص هنگام استفاده از مکانیزم‌های تلاش مجدد. این امر از اثرات ناخواسته در صورتی که یک درخواست به دلیل قطعی سرویس و تلاش‌های مجدد چندین بار اجرا شود، جلوگیری می‌کند.
• استفاده از مدار شکن‌ها در ترکیب با سایر الگوهای تحمل‌پذیری در برابر خطا: الگوی مدار شکن به خوبی با سایر الگوهای تحمل‌پذیری در برابر خطا مانند تلاش‌های مجدد و جداکننده‌ها (bulkheads) کار می‌کند تا یک راه‌حل جامع ارائه دهد. این امر یک دفاع چند لایه ایجاد می‌کند.
• مستندسازی پیکربندی مدار شکن خود: پیکربندی مدار شکن‌های خود، از جمله آستانه شکست، زمان تلاش مجدد و هر پارامتر مرتبط دیگر را به وضوح مستند کنید. این امر قابلیت نگهداری را تضمین کرده و عیب‌یابی را آسان می‌کند.

مثال‌های دنیای واقعی و تأثیر جهانی

الگوی مدار شکن به طور گسترده در صنایع و برنامه‌های مختلف در سراسر جهان استفاده می‌شود. برخی از مثال‌ها عبارتند از:

• تجارت الکترونیک: هنگام پردازش پرداخت‌ها یا تعامل با سیستم‌های موجودی. (به عنوان مثال، خرده‌فروشان در ایالات متحده و اروپا از مدار شکن‌ها برای مدیریت قطعی‌های درگاه پرداخت استفاده می‌کنند.)
• خدمات مالی: در بانکداری آنلاین و پلتفرم‌های معاملاتی، برای محافظت در برابر مشکلات اتصال با APIهای خارجی یا فیدهای داده بازار. (به عنوان مثال، بانک‌های جهانی از مدار شکن‌ها برای مدیریت قیمت‌های لحظه‌ای سهام از بورس‌های سراسر جهان استفاده می‌کنند.)
• رایانش ابری: در معماری‌های میکروسرویس، برای مدیریت شکست‌های سرویس و حفظ در دسترس بودن برنامه. (به عنوان مثال، ارائه‌دهندگان بزرگ ابر مانند AWS، Azure و Google Cloud Platform از مدار شکن‌ها در داخل برای مدیریت مشکلات سرویس استفاده می‌کنند.)
• مراقبت‌های بهداشتی: در سیستم‌های ارائه دهنده داده‌های بیمار یا تعامل با APIهای دستگاه‌های پزشکی. (به عنوان مثال، بیمارستان‌ها در ژاپن و استرالیا از مدار شکن‌ها در سیستم‌های مدیریت بیماران خود استفاده می‌کنند.)
• صنعت مسافرت: هنگام برقراری ارتباط با سیستم‌های رزرو هواپیمایی یا خدمات رزرو هتل. (به عنوان مثال، آژانس‌های مسافرتی که در چندین کشور فعالیت می‌کنند از مدار شکن‌ها برای مقابله با APIهای خارجی غیرقابل اعتماد استفاده می‌کنند.)

این مثال‌ها تطبیق‌پذیری و اهمیت الگوی مدار شکن را در ساخت برنامه‌های مستحکم و قابل اعتماد که می‌توانند در برابر شکست‌ها مقاومت کرده و تجربه کاربری بدون وقفه را ارائه دهند، صرف نظر از موقعیت جغرافیایی کاربر، نشان می‌دهند.

ملاحظات پیشرفته

فراتر از اصول اولیه، موضوعات پیشرفته‌تری برای در نظر گرفتن وجود دارد:

• الگوی جدا کننده (Bulkhead Pattern): مدار شکن‌ها را با الگوی جدا کننده ترکیب کنید تا شکست‌ها را ایزوله کنید. الگوی جدا کننده تعداد درخواست‌های همزمان به یک سرویس خاص را محدود می‌کند و از ناکامی یک سرویس معیوب جلوگیری می‌کند که کل سیستم را از کار بیاندازد.
• محدودیت نرخ (Rate Limiting): محدودیت نرخ را در کنار مدار شکن‌ها برای محافظت از سرویس‌ها در برابر اضافه بار پیاده‌سازی کنید. این امر به جلوگیری از طغیان یک سرویس که در حال حاضر با مشکل مواجه است، کمک می‌کند.
• انتقال وضعیت سفارشی: می‌توانید انتقال وضعیت مدار شکن را سفارشی کنید تا منطق مدیریت خطای پیچیده‌تری را پیاده‌سازی کنید.
• مدارهای شکن توزیع شده: در یک محیط توزیع شده، ممکن است به مکانیزمی برای همگام‌سازی وضعیت مدارهای شکن در چندین نمونه از برنامه خود نیاز داشته باشید. استفاده از یک فروشگاه پیکربندی متمرکز یا یک مکانیزم قفل توزیع شده را در نظر بگیرید.
• نظارت و داشبورد: مدار شکن خود را با ابزارهای نظارت و داشبورد ادغام کنید تا دید در لحظه به سلامت سرویس‌ها و عملکرد مدارهای شکن خود داشته باشید.

نتیجه‌گیری

الگوی مدار شکن یک ابزار حیاتی برای ساخت برنامه‌های پایتون تحمل‌پذیر در برابر خطا و مقاوم است، به ویژه در زمینه سیستم‌های توزیع شده و میکروسرویس‌ها. با پیاده‌سازی این الگو، می‌توانید پایداری، در دسترس بودن و تجربه کاربری برنامه‌های خود را به طور قابل توجهی بهبود بخشید. از جلوگیری از شکست‌های آبشاری گرفته تا مدیریت مطلوب خطاها، مدار شکن یک رویکرد فعال برای مدیریت خطرات ذاتی سیستم‌های نرم‌افزاری پیچیده ارائه می‌دهد. پیاده‌سازی مؤثر آن، همراه با سایر تکنیک‌های تحمل‌پذیری در برابر خطا، تضمین می‌کند که برنامه‌های شما آماده مقابله با چالش‌های چشم‌انداز دیجیتال در حال تحول مداوم هستند.

با درک مفاهیم، پیاده‌سازی بهترین شیوه‌ها و استفاده از کتابخانه‌های موجود پایتون، می‌توانید برنامه‌هایی ایجاد کنید که مستحکم‌تر، قابل اعتمادتر و کاربرپسندتر برای مخاطبان جهانی باشند.