Python Circuit Breaker: בניית יישומים סובלניים לתקלות

בעולם של מערכות מבוזרות ושירותים זעירים, התמודדות עם תקלות היא בלתי נמנעת. שירותים עלולים להפוך ללא זמינים עקב בעיות רשת, שרתים עמוסים או באגים בלתי צפויים. כאשר שירות כושל אינו מטופל כראוי, זה יכול להוביל לכשלים מדורגים, ולהפיל מערכות שלמות. דפוס Circuit Breaker הוא טכניקה רבת עוצמה למניעת כשלים מדורגים אלה ולבניית יישומים עמידים יותר. מאמר זה מספק מדריך מקיף ליישום דפוס Circuit Breaker ב-Python.

מהו דפוס Circuit Breaker?

דפוס Circuit Breaker, בהשראת מפסקי זרם חשמליים, משמש כפרוקסי עבור פעולות שעלולות להיכשל. הוא מנטר את שיעורי ההצלחה והכישלון של פעולות אלה, וכאשר מגיע סף מסוים של כשלים, הוא "מפעיל" את המעגל, ומונע קריאות נוספות לשירות הכושל. זה מאפשר לשירות הכושל זמן להתאושש מבלי להיות מוצף בבקשות, ומונע משירות הקריאה לבזבז משאבים בניסיון להתחבר לשירות הידוע כלא פעיל.

ל-Circuit Breaker יש שלושה מצבים עיקריים:

• סגור: ה-Circuit Breaker נמצא במצבו הרגיל, ומאפשר לקריאות לעבור לשירות המוגן. הוא מנטר את ההצלחה והכישלון של קריאות אלה.
• פתוח: ה-Circuit Breaker הופעל וכל הקריאות לשירות המוגן נחסמות. לאחר תקופת זמן קצובה, ה-Circuit Breaker עובר למצב Half-Open.
• Half-Open: ה-Circuit Breaker מאפשר מספר מוגבל של קריאות בדיקה לשירות המוגן. אם קריאות אלה מצליחות, ה-Circuit Breaker חוזר למצב סגור. אם הם נכשלים, הוא חוזר למצב פתוח.

הנה אנלוגיה פשוטה: תארו לעצמכם שאתם מנסים למשוך כסף מכספומט. אם הכספומט נכשל שוב ושוב למשוך מזומנים (אולי עקב שגיאת מערכת בבנק), ה-Circuit Breaker ייכנס לפעולה. במקום להמשיך ולנסות משיכות שצפויות להיכשל, ה-Circuit Breaker יחסום זמנית ניסיונות נוספים (מצב פתוח). לאחר זמן מה, זה עשוי לאפשר ניסיון משיכה בודד (מצב Half-Open). אם ניסיון זה מצליח, ה-Circuit Breaker יחזור לפעולה רגילה (מצב סגור). אם זה נכשל, ה-Circuit Breaker יישאר במצב פתוח למשך תקופה ארוכה יותר.

למה להשתמש ב-Circuit Breaker?

יישום Circuit Breaker מציע מספר יתרונות:

• מונע כשלים מדורגים: על ידי חסימת קריאות לשירות כושל, ה-Circuit Breaker מונע מהכשל להתפשט לחלקים אחרים של המערכת.
• משפר את חוסן המערכת: ה-Circuit Breaker מאפשר לשירותים כושלים זמן להתאושש מבלי להיות מוצפים בבקשות, מה שמוביל למערכת יציבה ועמידה יותר.
• מפחית את צריכת המשאבים: על ידי הימנעות מקריאות מיותרות לשירות כושל, ה-Circuit Breaker מפחית את צריכת המשאבים הן בשירות הקריאה והן בשירות הנקרא.
• מספק מנגנוני גיבוי: כאשר המעגל פתוח, שירות הקריאה יכול לבצע מנגנון גיבוי, כגון החזרת ערך שמור או הצגת הודעת שגיאה, מה שמספק חווית משתמש טובה יותר.

יישום Circuit Breaker ב-Python

ישנן מספר דרכים ליישום דפוס Circuit Breaker ב-Python. ניתן לבנות יישום משלך מאפס, או שניתן להשתמש בספריית צד שלישי. כאן, נחקור את שתי הגישות.

1. בניית Circuit Breaker מותאם אישית

בואו נתחיל עם יישום בסיסי ומותאם אישית כדי להבין את מושגי הליבה. דוגמה זו משתמשת במודול `threading` לבטיחות השרשור ובמודול `time` לטיפול בזמני תפוגה.

            
import time
import threading

class CircuitBreaker:
    def __init__(self, failure_threshold, recovery_timeout):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.state = "CLOSED"
        self.failure_count = 0
        self.last_failure_time = None
        self.lock = threading.Lock()

    def call(self, func, *args, **kwargs):
        with self.lock:
            if self.state == "OPEN":
                if time.time() - self.last_failure_time > self.recovery_timeout:
                    self.state = "HALF_OPEN"
                else:
                    raise CircuitBreakerError("Circuit breaker is open")

        try:
            result = func(*args, **kwargs)
            self.reset()
            return result
        except Exception as e:
            self.record_failure()
            raise e

    def record_failure(self):
        with self.lock:
            self.failure_count += 1
            self.last_failure_time = time.time()

            if self.failure_count >= self.failure_threshold:
                self.state = "OPEN"
                print("Circuit breaker opened")

    def reset(self):
        with self.lock:
            self.failure_count = 0
            self.state = "CLOSED"
            print("Circuit breaker closed")

class CircuitBreakerError(Exception):
    pass

# Example Usage
def unreliable_service():
    # Simulate a service that sometimes fails
    import random
    if random.random() < 0.5:
        raise Exception("Service failed")
    else:
        return "Service successful"

circuit_breaker = CircuitBreaker(failure_threshold=3, recovery_timeout=10)

for i in range(10):
    try:
        result = circuit_breaker.call(unreliable_service)
        print(f"Call {i+1}: {result}")
    except CircuitBreakerError as e:
        print(f"Call {i+1}: {e}")
    except Exception as e:
        print(f"Call {i+1}: Service failed: {e}")
    time.sleep(1)

            

              
                Copy
              
            
          

הסבר:

• מחלקת `CircuitBreaker`:
  • `__init__(self, failure_threshold, recovery_timeout)`: מאתחל את ה-Circuit Breaker עם סף כשל (מספר הכשלים לפני הפעלת המעגל), זמן קצוב להתאוששות (הזמן להמתין לפני ניסיון מצב חצי פתוח), ומגדיר את המצב ההתחלתי ל-`CLOSED`.
  • `call(self, func, *args, **kwargs)`: זוהי השיטה העיקרית שעוטפת את הפונקציה שברצונך להגן עליה. היא בודקת את המצב הנוכחי של ה-Circuit Breaker. אם זה `OPEN`, זה בודק אם פג תוקף זמן ההתאוששות. אם כן, הוא עובר ל-`HALF_OPEN`. אחרת, הוא מעלה את ה-`CircuitBreakerError`. אם המצב אינו `OPEN`, הוא מבצע את הפונקציה ומטפל בחריגים פוטנציאליים.
  • `record_failure(self)`: מגדיל את ספירת הכשלים ומתעד את זמן הכשל. אם ספירת הכשלים חורגת מהסף, הוא מעביר את המעגל למצב `OPEN`.
  • `reset(self)`: מאפס את ספירת הכשלים ומעביר את המעגל למצב `CLOSED`.
• מחלקה `CircuitBreakerError`: חריג מותאם אישית המועלה כאשר ה-Circuit Breaker פתוח.
• פונקציה `unreliable_service()`: מדמה שירות שנכשל באופן אקראי.
• דוגמה לשימוש: מדגים כיצד להשתמש במחלקה `CircuitBreaker` כדי להגן על הפונקציה `unreliable_service()`.

שיקולים מרכזיים ליישום מותאם אישית:

• בטיחות חוטים: ה-`threading.Lock()` הוא קריטי להבטחת בטיחות חוטים, במיוחד בסביבות מקבילות.
• טיפול בשגיאות: בלוק ה-`try...except` לוכד חריגים מהשירות המוגן וקורא ל-`record_failure()`.
• מעברי מצב: ההיגיון למעבר בין המצבים `CLOSED`, `OPEN` ו-`HALF_OPEN` מיושם בשיטות `call()` ו-`record_failure()`.

2. שימוש בספריית צד שלישי: `pybreaker`

בעוד שבניית Circuit Breaker משלך יכולה להיות חוויית למידה טובה, שימוש בספריית צד שלישי שנבדקה היטב הוא לרוב אפשרות טובה יותר עבור סביבות ייצור. ספריית Python פופולרית אחת ליישום דפוס Circuit Breaker היא `pybreaker`.

התקנה:

            
pip install pybreaker

            

              
                Copy
              
            
          

דוגמה לשימוש:

            
import pybreaker
import time

# Define a custom exception for our service
class ServiceError(Exception):
    pass

# Simulate an unreliable service
def unreliable_service():
    import random
    if random.random() < 0.5:
        raise ServiceError("Service failed")
    else:
        return "Service successful"

# Create a CircuitBreaker instance
circuit_breaker = pybreaker.CircuitBreaker(
    fail_max=3,  # Number of failures before opening the circuit
    reset_timeout=10,  # Time in seconds before attempting to close the circuit
    name="MyService"
)

# Wrap the unreliable service with the CircuitBreaker
@circuit_breaker
def call_unreliable_service():
    return unreliable_service()

# Make calls to the service
for i in range(10):
    try:
        result = call_unreliable_service()
        print(f"Call {i+1}: {result}")
    except pybreaker.CircuitBreakerError as e:
        print(f"Call {i+1}: Circuit breaker is open: {e}")
    except ServiceError as e:
        print(f"Call {i+1}: Service failed: {e}")
    time.sleep(1)

            

              
                Copy
              
            
          

הסבר:

• התקנה: הפקודה `pip install pybreaker` מתקינה את הספריה.
• מחלקה `pybreaker.CircuitBreaker`:
  • `fail_max`: מציין את מספר הכשלים הרצופים לפני שה-Circuit Breaker נפתח.
  • `reset_timeout`: מציין את הזמן (בשניות) שה-Circuit Breaker נשאר פתוח לפני המעבר למצב חצי פתוח.
  • `name`: שם תיאורי עבור ה-Circuit Breaker.
• קישוט: הקישוט `@circuit_breaker` עוטף את הפונקציה `unreliable_service()`, ומטפל אוטומטית בהיגיון ה-Circuit Breaker.
• טיפול בחריגות: הבלוק `try...except` לוכד `pybreaker.CircuitBreakerError` כאשר המעגל פתוח ו-`ServiceError` (החריג המותאם אישית שלנו) כאשר השירות נכשל.

היתרונות של שימוש ב-`pybreaker`:

• יישום פשוט: `pybreaker` מספק ממשק API נקי וקל לשימוש, המפחית את קוד ה-boilerplate.
• בטיחות חוטים: `pybreaker` הוא בטוח לחוטים, מה שהופך אותו למתאים ליישומים מקבילים.
• ניתן להתאמה אישית: ניתן להגדיר פרמטרים שונים, כגון סף הכשל, זמן קצוב לאיפוס ומאזיני אירועים.
• מאזיני אירועים: `pybreaker` תומך במאזיני אירועים, המאפשרים לך לנטר את מצב ה-Circuit Breaker ולנקוט בפעולות בהתאם (למשל, רישום, שליחת התראות).

3. מושגי Circuit Breaker מתקדמים

מעבר ליישום הבסיסי, ישנם מספר מושגים מתקדמים שיש לקחת בחשבון בעת שימוש ב-Circuit Breakers:

• מדדים וניטור: איסוף מדדים על הביצועים של ה-Circuit Breakers שלך הוא חיוני להבנת ההתנהגות שלהם ולזיהוי בעיות פוטנציאליות. ניתן להשתמש בספריות כמו Prometheus ו-Grafana כדי להמחיש מדדים אלה. עקוב אחר מדדים כגון:
• מצב Circuit Breaker (פתוח, סגור, חצי פתוח)
• מספר קריאות מוצלחות
• מספר קריאות שנכשלו
• חביון של קריאות
• מנגנוני גיבוי: כאשר המעגל פתוח, אתה צריך אסטרטגיה לטיפול בבקשות. מנגנוני גיבוי נפוצים כוללים:
• החזרת ערך שמור.
• הצגת הודעת שגיאה למשתמש.
• קריאה לשירות חלופי.
• החזרת ערך ברירת מחדל.
• Circuit Breakers אסינכרוניים: ביישומים אסינכרוניים (באמצעות `asyncio`), תצטרך להשתמש ביישום Circuit Breaker אסינכרוני. חלק מהספריות מציעות תמיכה אסינכרונית.
• Bulkheads: דפוס ה-Bulkhead מבודד חלקים של יישום כדי למנוע כשלים בחלק אחד מלהתפשט לאחרים. ניתן להשתמש ב-Circuit Breakers בשילוב עם Bulkheads כדי לספק סובלנות תקלות גבוהה עוד יותר.
• Circuit Breakers מבוססי זמן: במקום לעקוב אחר מספר הכשלים, Circuit Breaker מבוסס זמן פותח את המעגל אם זמן התגובה הממוצע של השירות המוגן חורג מסף מסוים בתוך חלון זמן נתון.

דוגמאות מעשיות ומקרי שימוש

הנה כמה דוגמאות מעשיות לאופן שבו ניתן להשתמש ב-Circuit Breakers בתרחישים שונים:

• ארכיטקטורת שירותים זעירים: בארכיטקטורת שירותים זעירים, שירותים תלויים זה בזה לעתים קרובות. Circuit Breaker יכול להגן על שירות מפני הצפה על ידי כשלים בשירות במורד הזרם. לדוגמה, ליישום מסחר אלקטרוני עשויים להיות שירותים זעירים נפרדים עבור קטלוג מוצרים, עיבוד הזמנות ועיבוד תשלומים. אם שירות עיבוד התשלומים הופך ללא זמין, Circuit Breaker בשירות עיבוד ההזמנות יכול למנוע יצירת הזמנות חדשות, ולמנוע כשל מדורג.
• חיבורי מסד נתונים: אם היישום שלך מתחבר לעתים קרובות למסד נתונים, Circuit Breaker יכול למנוע סערות חיבור כאשר מסד הנתונים אינו זמין. שקול יישום שמתחבר למסד נתונים מבוזר גיאוגרפית. אם הפסקת רשת משפיעה על אחד מאזורי מסד הנתונים, Circuit Breaker יכול למנוע מהיישום לנסות שוב ושוב להתחבר לאזור הלא זמין, מה שמשפר את הביצועים והיציבות.
• ממשקי API חיצוניים: בעת קריאה לממשקי API חיצוניים, Circuit Breaker יכול להגן על היישום שלך מפני שגיאות וכיבויים חולפים. ארגונים רבים מסתמכים על ממשקי API של צד שלישי עבור פונקציונליות שונות. על ידי עטיפת קריאות API עם Circuit Breaker, ארגונים יכולים לבנות אינטגרציות חזקות יותר ולהפחית את ההשפעה של כשלים ב-API חיצוניים.
• היגיון ניסיונות חוזרים: Circuit Breakers יכולים לעבוד בשילוב עם היגיון ניסיונות חוזרים. עם זאת, חשוב להימנע מניסיונות חוזרים אגרסיביים שעלולים להחמיר את הבעיה. ה-Circuit Breaker צריך למנוע ניסיונות חוזרים כאשר ידוע שהשירות אינו זמין.

שיקולים גלובליים

בעת יישום Circuit Breakers בהקשר גלובלי, חשוב לקחת בחשבון את הדברים הבאים:

• חביון רשת: חביון הרשת יכול להשתנות באופן משמעותי בהתאם למיקום הגיאוגרפי של שירותי הקריאה והקריאה. התאם את זמן ההתאוששות בהתאם. לדוגמה, קריאות בין שירותים בצפון אמריקה ובאירופה עשויות לחוות חביון גבוה יותר מאשר קריאות בתוך אותו אזור.
• אזורי זמן: ודא שכל חותמות הזמן מטופלות באופן עקבי על פני אזורי זמן שונים. השתמש ב-UTC לאחסון חותמות זמן.
• הפסקות אזוריות: שקול את האפשרות של הפסקות אזוריות ויישם Circuit Breakers כדי לבודד כשלים לאזורים ספציפיים.
• שיקולים תרבותיים: בעת עיצוב מנגנוני גיבוי, שקול את ההקשר התרבותי של המשתמשים שלך. לדוגמה, הודעות שגיאה צריכות להיות מותאמות לשפה ומותאמות מבחינה תרבותית.

שיטות עבודה מומלצות

הנה כמה שיטות עבודה מומלצות לשימוש יעיל ב-Circuit Breakers:

• התחל עם הגדרות שמרניות: התחל עם סף כשל נמוך יחסית וזמן קצוב ארוך יותר להתאוששות. עקוב אחר התנהגות ה-Circuit Breaker והתאם את ההגדרות לפי הצורך.
• השתמש במנגנוני גיבוי מתאימים: בחר מנגנוני גיבוי המספקים חווית משתמש טובה וממזערים את ההשפעה של כשלים.
• נטר את מצב ה-Circuit Breaker: עקוב אחר המצב של ה-Circuit Breakers שלך והגדר התראות כדי להודיע לך כאשר מעגל פתוח.
• בדוק את התנהגות ה-Circuit Breaker: הדמיה כשלים בסביבת הבדיקה שלך כדי לוודא שה-Circuit Breakers שלך פועלים כראוי.
• הימנע מהסתמכות יתר על Circuit Breakers: Circuit Breakers הם כלי להפחתת כשלים, אך הם אינם תחליף לטיפול בגורמים הבסיסיים לכשלים אלה. חקור ותקן את שורשי חוסר היציבות בשירות.
• שקול מעקב מבוזר: שלב כלי מעקב מבוזרים (כגון Jaeger או Zipkin) כדי לעקוב אחר בקשות על פני מספר שירותים. זה יכול לעזור לך לזהות את שורש הכשל ולהבין את ההשפעה של Circuit Breakers על המערכת הכוללת.

סיכום

דפוס Circuit Breaker הוא כלי רב ערך לבניית יישומים סובלניים לתקלות ועמידים. על ידי מניעת כשלים מדורגים ואפשרות לשירותים כושלים זמן להתאושש, Circuit Breakers יכולים לשפר משמעותית את יציבות המערכת ואת הזמינות. בין אם תבחר לבנות יישום משלך או להשתמש בספריית צד שלישי כמו `pybreaker`, הבנת מושגי הליבה ושיטות העבודה המומלצות של דפוס Circuit Breaker היא חיונית לפיתוח תוכנה חזקה ואמינה בסביבות מבוזרות מורכבות של היום.

על ידי יישום העקרונות המתוארים במדריך זה, תוכל לבנות יישומי Python העמידים יותר לתקלות, מה שמבטיח חווית משתמש טובה יותר ומערכת יציבה יותר, ללא קשר לתפוצה הגלובלית שלך.