How to incorporate circuit breaker in microservices architecture

Within a microservices architecture, a circuit breaker serves as a design pattern to effectively manage failures and mitigate the risk of cascading failures caused by a failed microservice. Like an electrical circuit breaker, this pattern is designed to “trip” and halt further execution of requests when a certain threshold of failures is reached. This prevents the system from persistently calling a failed service, giving ample time for the failed service to recover.

The circuit breaker pattern

The circuit breaker pattern has three main states, as discussed below:

Closed state

When in the closed state, the circuit breaker permits the passage of requests to the underlying component. It monitors the component’s performance, such as the failure rate or response times. If the monitored metrics are within acceptable limits, the circuit remains closed, and requests are processed as usual.

Circuit breaker pattern in the closed state
Circuit breaker pattern in the closed state

Open state

When the monitored metrics, such as the failure rate, exceed a predefined threshold, the circuit breaker transitions to the open state. In the open state, the circuit breaker does not allow requests to pass through to the failing component. Instead of making calls likely to fail, the system may take alternative actions, such as returning cached data, providing default values, or invoking a fallback mechanism. The open state helps prevent further stress on the failing component, giving it time to recover.

Circuit breaker pattern in the open state
Circuit breaker pattern in the open state

Half-open state

After a specified time in the open state, the circuit breaker shifts to the half-open state. In the half-open state, a limited number of requests are allowed to pass through to the underlying component to check if it has recovered. If these test requests are processed successfully, the circuit breaker returns to the closed state and normal operation resumes. If the test requests continue to fail, the circuit breaker may remain in the open state, providing more time for the underlying component to recover before allowing full traffic.

Each state of a circuit breaker is depicted in the following figure:

The three different states of a circuit breaker
The three different states of a circuit breaker

Where to place a circuit breaker

In a microservices architecture, the circuit breaker pattern is typically applied at the boundary between microservices or when a service calls an external dependency (e.g., another microservice, a database, or a third-party API). Placing the circuit breaker strategically helps isolate and contain failures, preventing them from cascading throughout the system. The following are common scenarios to place the circuit breaker in a microservices architecture:

  • Around external service calls: Apply the circuit breaker pattern around calls to external services or dependencies. This ensures that if an external service experiences issues, the circuit breaker can open, and the system can gracefully handle the failure without causing a cascade of failures in the calling service.

Circuit breaker around external service
Circuit breaker around external service

  • Between microservices: Place the circuit breaker at the point where one microservice calls another microservice. This is particularly important in a microservices architecture where services communicate over a network. The circuit breaker helps prevent failures in one microservice from affecting others.

Circuit breaker between different services
Circuit breaker between different services

  • Before critical operations: Apply the circuit breaker before critical or resource-intensive operations. For example, if a microservice relies on a database, a circuit breaker can be placed around database calls to handle failures or excessive response times.

Circuit breaker before critical operations
Circuit breaker before critical operations

  • At the edge of the system: Consider placing circuit breakers at the edge of the system, where external requests enter. This can help protect the overall system from failures originating from external clients.

Circuit breaker at the edge of the system
Circuit breaker at the edge of the system

Utilizing a circuit breaker in a service call

Let’s demonstrate the working of a circuit breaker using Python programming language. The following code wraps a call to simulated service with a circuit breaker. At the end, the code also shows the current status of the circuit breaker, as shown below:

from pybreaker import CircuitBreaker
import httpx
def service_call():
    # This function simulate a successful service call
    print("The similulation to call a service is completed, successfully.")
# Create a Circuit Breaker
breaker = CircuitBreaker(fail_max=3, reset_timeout=10)
try:
    with httpx.Client() as client:
        # Wrap the call to the service with the circuit breaker
        breaker.call(client.get, "https://example.com")
    
    service_call()
    print("Service is called successfully.")
except Exception as e:
    print(f"Oh no, the service call failed: {e}")
# Circuit breaker status
print("The current status of the circuit breaker is:", breaker.current_state)

Code explanation

  • Line 1: Import the required modules and classes from the pybreaker library. CircuitBreaker is the main class for creating a circuit breaker. It also imports the httpx module for making HTTP requests.

  • Line 4–6: Define a function service_call() that simulates a successful external service call.

  • Line 9: Create an instance of the CircuitBreaker class named breaker. Here, we also configure the circuit breaker with a maximum failure count of 3 (fail_max=3) and a reset timeout of 10 seconds (reset_timeout=10).

  • Line 11–20: Use a try block to encapsulate the code involving an external service call.

  • Line 23: Print the current status of the circuit breaker.

In essence, a circuit breaker is a pattern that safeguards a microservice architecture from cascading failures. When a failure occurs, or a service goes down, it halts the traffic until the system recovers. Primarily, its three states—open, closed, and half-open—play a crucial role in determining the next course of action.

Free Resources

Copyright ©2025 Educative, Inc. All rights reserved