Examples of Circuit Breaker Pattern in Microservices

Understanding the Circuit Breaker Pattern in Microservices

The circuit breaker pattern is a crucial design pattern in microservices architecture that helps manage failures and prevent cascading errors. By acting as a protective layer, it allows a service to fail gracefully, giving it time to recover while maintaining the overall system’s integrity. This pattern is particularly useful in scenarios where services are interdependent and the failure of one can lead to the failure of others. Below are three diverse, practical examples of the circuit breaker pattern in microservices.

Example 1: Weather Data Service

Context

In a microservices architecture where a weather data service relies on an external API to fetch real-time weather information, network issues or downtime from the third-party service can disrupt the entire application.

The circuit breaker pattern can be implemented to handle such failures gracefully.

Implementation

const circuitBreaker = require('opossum');

const fetchWeatherData = async () => {
    // Simulate fetching data from an external API
    // This could throw an error if the API is down
};

const options = {
    timeout: 3000, // If the API takes longer than 3 seconds, trigger the circuit breaker
    errorThresholdPercentage: 50, // Open the circuit if 50% of requests fail
    resetTimeout: 10000 // After 10 seconds, allow a test request to the API
};

const breaker = circuitBreaker(fetchWeatherData, options);

breaker.fire()
    .then(data => console.log('Weather Data:', data))
    .catch(err => console.error('Error fetching weather data:', err));

Notes

• The circuit breaker opens when the error threshold is exceeded, preventing further requests until it resets.
• This allows the service to return cached or default data instead of failing completely.

Example 2: Payment Processing Service

Context

In an e-commerce application, the payment processing microservice connects to multiple payment gateways. If one of the gateways becomes unresponsive, it can lead to delays and a poor customer experience.

Implementing a circuit breaker can help mitigate this risk.

Implementation

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;

CircuitBreakerConfig config = CircuitBreakerConfig.custom()
    .failureRateThreshold(50)
    .waitDurationInOpenState(Duration.ofSeconds(10))
    .permittedNumberOfCallsInHalfOpenState(3)
    .slidingWindowSize(5)
    .build();

CircuitBreakerRegistry registry = CircuitBreakerRegistry.of(config);
CircuitBreaker circuitBreaker = registry.circuitBreaker("paymentService");

String response = circuitBreaker.executeSupplier(() -> paymentGateway.processPayment(paymentDetails));

Notes

• This example uses the Resilience4j library for implementing the circuit breaker in a Java-based microservice.
• The circuit breaker will allow a limited number of requests during its half-open state to check if the service is recoverable.

Example 3: User Profile Service

Context

In a social media application, the user profile service fetches user data from a database. If the database experiences high latency or downtime, it can lead to performance degradation across the application.

Utilizing a circuit breaker can help manage these scenarios.

Implementation

from pybreaker import CircuitBreaker

circuit_breaker = CircuitBreaker(failure_threshold=0.5, recovery_time=10)

def get_user_profile(user_id):
#    # Simulate fetching user profile from a database
    pass

try:
    user_profile = circuit_breaker.call(get_user_profile, user_id)
except Exception as e:
    print(f'Circuit breaker opened: {e}')

Notes

• This Python example uses the pybreaker library to implement the circuit breaker.
• The failure threshold is set to 50%, meaning if more than half of the requests fail, the circuit breaker will open.

By incorporating the circuit breaker pattern in microservices, developers can enhance the resilience and reliability of their applications, ensuring a smoother user experience even in the face of failures.