Python Circuit Breaker: 내결함성 애플리케이션 구축

분산 시스템 및 마이크로서비스 환경에서 오류 처리는 피할 수 없습니다. 네트워크 문제, 과부하된 서버 또는 예기치 않은 버그로 인해 서비스가 사용 불가능해질 수 있습니다. 실패한 서비스를 제대로 처리하지 못하면 연쇄적인 실패로 이어져 전체 시스템이 다운될 수 있습니다. Circuit Breaker 패턴은 이러한 연쇄적인 실패를 방지하고 보다 탄력적인 애플리케이션을 구축하는 강력한 기술입니다. 이 기사에서는 Python에서 Circuit Breaker 패턴을 구현하는 방법에 대한 포괄적인 가이드를 제공합니다.

Circuit Breaker 패턴이란 무엇입니까?

전기 회로 차단기에서 영감을 얻은 Circuit Breaker 패턴은 실패할 수 있는 작업에 대한 프록시 역할을 합니다. 이러한 작업의 성공 및 실패율을 모니터링하고 특정 실패 임계값에 도달하면 회로를 "트립"시켜 실패한 서비스에 대한 추가 호출을 방지합니다. 이를 통해 실패한 서비스는 요청에 압도되지 않고 복구할 시간을 가질 수 있으며, 호출 서비스는 다운된 것으로 알려진 서비스에 연결하려고 리소스를 낭비하는 것을 방지할 수 있습니다.

Circuit Breaker에는 세 가지 주요 상태가 있습니다.

• Closed: Circuit Breaker는 정상 상태이며, 호출이 보호된 서비스를 통과하도록 허용합니다. 이러한 호출의 성공 및 실패를 모니터링합니다.
• Open: Circuit Breaker가 트립되어 보호된 서비스에 대한 모든 호출이 차단됩니다. 지정된 시간 초과 기간 후 Circuit Breaker는 Half-Open 상태로 전환됩니다.
• Half-Open: Circuit Breaker는 제한된 수의 테스트 호출을 보호된 서비스에 허용합니다. 이러한 호출이 성공하면 Circuit Breaker는 Closed 상태로 돌아갑니다. 실패하면 Open 상태로 돌아갑니다.

다음은 간단한 비유입니다. ATM에서 돈을 인출하려고 한다고 상상해 보세요. ATM이 반복적으로 현금을 지급하지 못하는 경우(예: 은행 시스템 오류로 인해) Circuit Breaker가 개입합니다. 실패할 가능성이 높은 인출 시도를 계속하는 대신 Circuit Breaker는 일시적으로 추가 시도를 차단합니다(Open 상태). 잠시 후 단일 인출 시도를 허용할 수 있습니다(Half-Open 상태). 해당 시도가 성공하면 Circuit Breaker는 정상 작동을 재개합니다(Closed 상태). 실패하면 Circuit Breaker는 더 긴 기간 동안 Open 상태를 유지합니다.

Circuit Breaker를 사용하는 이유는 무엇입니까?

Circuit Breaker를 구현하면 다음과 같은 여러 가지 이점이 있습니다.

• 연쇄적인 실패 방지: 실패한 서비스에 대한 호출을 차단함으로써 Circuit Breaker는 시스템의 다른 부분으로 실패가 확산되는 것을 방지합니다.
• 시스템 복원력 향상: Circuit Breaker는 실패한 서비스가 요청에 압도되지 않고 복구할 시간을 허용하여 보다 안정적이고 탄력적인 시스템을 만듭니다.
• 리소스 소비 감소: 실패한 서비스에 대한 불필요한 호출을 피함으로써 Circuit Breaker는 호출 서비스와 호출되는 서비스 모두에서 리소스 소비를 줄입니다.
• 대체 메커니즘 제공: 회로가 열려 있으면 호출 서비스는 캐시된 값을 반환하거나 오류 메시지를 표시하는 등의 대체 메커니즘을 실행하여 더 나은 사용자 환경을 제공할 수 있습니다.

Python에서 Circuit Breaker 구현

Python에서 Circuit Breaker 패턴을 구현하는 방법에는 여러 가지가 있습니다. 처음부터 직접 구현하거나 타사 라이브러리를 사용할 수 있습니다. 여기서는 두 가지 접근 방식을 모두 살펴봅니다.

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)`: 실패 임계값(회로를 트립하기 전의 실패 횟수), 복구 시간 초과(Half-Open 상태를 시도하기 전에 대기하는 시간)로 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를 구축하는 것은 좋은 학습 경험이 될 수 있지만, 잘 테스트된 타사 라이브러리를 사용하는 것이 프로덕션 환경에서 더 나은 선택인 경우가 많습니다. Circuit Breaker 패턴을 구현하기 위한 인기 있는 Python 라이브러리 중 하나는 `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가 Half-Open 상태로 전환되기 전에 열려 있는 시간(초)을 지정합니다.
  • `name`: Circuit Breaker에 대한 설명적인 이름입니다.
• 데코레이터: `@circuit_breaker` 데코레이터는 `unreliable_service()` 함수를 래핑하여 Circuit Breaker 논리를 자동으로 처리합니다.
• 예외 처리: `try...except` 블록은 회로가 열려 있을 때 `pybreaker.CircuitBreakerError`를 포착하고 서비스가 실패할 때 `ServiceError`(사용자 정의 예외)를 포착합니다.

`pybreaker` 사용의 이점:

• 구현 단순화: `pybreaker`는 깔끔하고 사용하기 쉬운 API를 제공하여 상용구 코드를 줄입니다.
• 스레드 안전성: `pybreaker`는 스레드 안전하므로 동시 애플리케이션에 적합합니다.
• 사용자 정의 가능: 실패 임계값, 재설정 시간 초과 및 이벤트 리스너와 같은 다양한 매개변수를 구성할 수 있습니다.
• 이벤트 리스너: `pybreaker`는 이벤트 리스너를 지원하므로 Circuit Breaker의 상태를 모니터링하고 그에 따라 조치를 취할 수 있습니다(예: 로깅, 경고 보내기).

3. 고급 Circuit Breaker 개념

기본 구현 외에도 Circuit Breaker를 사용할 때 고려해야 할 몇 가지 고급 개념이 있습니다.

• 메트릭 및 모니터링: Circuit Breaker의 동작을 이해하고 잠재적인 문제를 식별하려면 성능에 대한 메트릭을 수집하는 것이 필수적입니다. Prometheus 및 Grafana와 같은 라이브러리를 사용하여 이러한 메트릭을 시각화할 수 있습니다. 다음과 같은 메트릭을 추적합니다.
• Circuit Breaker 상태(Open, Closed, Half-Open)
• 성공한 호출 횟수
• 실패한 호출 횟수
• 호출 대기 시간
• 대체 메커니즘: 회로가 열려 있을 때 요청을 처리하기 위한 전략이 필요합니다. 일반적인 대체 메커니즘은 다음과 같습니다.
• 캐시된 값 반환
• 사용자에게 오류 메시지 표시
• 대체 서비스 호출
• 기본값 반환
• 비동기 Circuit Breaker: 비동기 애플리케이션(`asyncio` 사용)에서는 비동기 Circuit Breaker 구현을 사용해야 합니다. 일부 라이브러리는 비동기 지원을 제공합니다.
• 벌크헤드: 벌크헤드 패턴은 애플리케이션의 일부를 격리하여 한 부분의 오류가 다른 부분으로 확산되는 것을 방지합니다. Circuit Breaker는 벌크헤드와 함께 사용하여 훨씬 더 강력한 내결함성을 제공할 수 있습니다.
• 시간 기반 Circuit Breaker: 실패 횟수를 추적하는 대신 시간 기반 Circuit Breaker는 보호된 서비스의 평균 응답 시간이 주어진 시간 창 내에서 특정 임계값을 초과하는 경우 회로를 엽니다.

실제 예제 및 사용 사례

다음은 다양한 시나리오에서 Circuit Breaker를 사용하는 방법에 대한 몇 가지 실제 예입니다.

• 마이크로서비스 아키텍처: 마이크로서비스 아키텍처에서 서비스는 서로 의존하는 경우가 많습니다. Circuit Breaker는 다운스트림 서비스의 오류로 인해 서비스가 압도되는 것을 방지할 수 있습니다. 예를 들어 전자 상거래 애플리케이션에는 제품 카탈로그, 주문 처리 및 결제 처리를 위한 별도의 마이크로서비스가 있을 수 있습니다. 결제 처리 서비스를 사용할 수 없게 되면 주문 처리 서비스의 Circuit Breaker는 새 주문이 생성되지 않도록 하여 연쇄적인 실패를 방지할 수 있습니다.
• 데이터베이스 연결: 애플리케이션이 데이터베이스에 자주 연결하는 경우 Circuit Breaker는 데이터베이스를 사용할 수 없을 때 연결 폭풍을 방지할 수 있습니다. 지리적으로 분산된 데이터베이스에 연결하는 애플리케이션을 고려해 보십시오. 네트워크 중단이 데이터베이스 영역 중 하나에 영향을 미치는 경우 Circuit Breaker는 애플리케이션이 사용할 수 없는 영역에 반복적으로 연결을 시도하는 것을 방지하여 성능과 안정성을 향상시킬 수 있습니다.
• 외부 API: 외부 API를 호출할 때 Circuit Breaker는 애플리케이션을 일시적인 오류 및 중단으로부터 보호할 수 있습니다. 많은 조직에서 다양한 기능을 위해 타사 API에 의존합니다. API 호출을 Circuit Breaker로 래핑함으로써 조직은 보다 강력한 통합을 구축하고 외부 API 오류의 영향을 줄일 수 있습니다.
• 재시도 논리: Circuit Breaker는 재시도 논리와 함께 작동할 수 있습니다. 그러나 문제를 악화시킬 수 있는 공격적인 재시도를 피하는 것이 중요합니다. Circuit Breaker는 서비스를 사용할 수 없는 것으로 알려진 경우 재시도를 방지해야 합니다.

글로벌 고려 사항

글로벌 컨텍스트에서 Circuit Breaker를 구현할 때는 다음 사항을 고려하는 것이 중요합니다.

• 네트워크 대기 시간: 네트워크 대기 시간은 호출 서비스와 호출되는 서비스의 지리적 위치에 따라 크게 다를 수 있습니다. 그에 따라 복구 시간 초과를 조정합니다. 예를 들어 북미와 유럽의 서비스 간의 호출은 동일한 지역 내의 호출보다 대기 시간이 더 길 수 있습니다.
• 시간대: 모든 타임스탬프가 다른 시간대에서 일관되게 처리되도록 합니다. 타임스탬프 저장에는 UTC를 사용합니다.
• 지역적 중단: 지역적 중단의 가능성을 고려하고 특정 지역으로 오류를 격리하기 위해 Circuit Breaker를 구현합니다.
• 문화적 고려 사항: 대체 메커니즘을 설계할 때 사용자의 문화적 맥락을 고려합니다. 예를 들어 오류 메시지는 현지화되고 문화적으로 적절해야 합니다.

모범 사례

다음은 Circuit Breaker를 효과적으로 사용하는 데 대한 몇 가지 모범 사례입니다.

• 보수적인 설정으로 시작: 비교적 낮은 실패 임계값과 더 긴 복구 시간 초과로 시작합니다. Circuit Breaker의 동작을 모니터링하고 필요에 따라 설정을 조정합니다.
• 적절한 대체 메커니즘 사용: 좋은 사용자 환경을 제공하고 오류의 영향을 최소화하는 대체 메커니즘을 선택합니다.
• Circuit Breaker 상태 모니터링: Circuit Breaker의 상태를 추적하고 회로가 열려 있을 때 알림을 보내도록 경고를 설정합니다.
• Circuit Breaker 동작 테스트: 테스트 환경에서 오류를 시뮬레이션하여 Circuit Breaker가 올바르게 작동하는지 확인합니다.
• Circuit Breaker에 대한 과도한 의존 방지: Circuit Breaker는 오류를 완화하기 위한 도구이지만 이러한 오류의 근본 원인을 해결하는 데 대한 대안은 아닙니다. 서비스 불안정의 근본 원인을 조사하고 수정합니다.
• 분산 추적 고려: 여러 서비스에서 요청을 추적하기 위해 분산 추적 도구(예: Jaeger 또는 Zipkin)를 통합합니다. 이렇게 하면 오류의 근본 원인을 식별하고 전체 시스템에 대한 Circuit Breaker의 영향을 이해하는 데 도움이 될 수 있습니다.

결론

Circuit Breaker 패턴은 내결함성 및 탄력적인 애플리케이션을 구축하는 데 유용한 도구입니다. Circuit Breaker는 연쇄적인 실패를 방지하고 실패한 서비스가 복구할 시간을 허용함으로써 시스템 안정성과 가용성을 크게 향상시킬 수 있습니다. 자체 구현을 구축하든 `pybreaker`와 같은 타사 라이브러리를 사용하든 오늘날의 복잡한 분산 환경에서 강력하고 안정적인 소프트웨어를 개발하려면 Circuit Breaker 패턴의 핵심 개념과 모범 사례를 이해하는 것이 필수적입니다.

이 가이드에 설명된 원칙을 구현하면 글로벌 범위에 관계없이 오류에 더 탄력적인 Python 애플리케이션을 구축하여 더 나은 사용자 경험과 더 안정적인 시스템을 보장할 수 있습니다.