What is Circuit Breaker - New Dev Point

A Circuit Breaker is a design pattern used in microservices architecture to handle potential failures in a more resilient and controlled way. It helps prevent cascading failures in distributed systems by monitoring interactions between services and stopping requests to failing services before they affect the entire system.

The Circuit Breaker pattern is used to wrap calls to external services, APIs, or microservices that might fail. If a service is slow, unresponsive, or failing consistently, the circuit breaker "opens," temporarily halting calls to the service. Once the service recovers, the circuit breaker "closes," allowing traffic to flow through again.

Motivation for Circuit Breaker

In microservices, if one service depends on another and that service becomes unavailable or slow, it can cause the calling service to also slow down or fail. Without a mechanism to handle such failures, the system can experience cascading failures where failures in one service spread to others. The Circuit Breaker pattern prevents this by isolating failures and preventing overloading of struggling services.

States of a Circuit Breaker

The Circuit Breaker typically has three states:

Closed:
- In the closed state, the circuit breaker allows requests to the external service or microservice.
- If failures occur (e.g., timeouts, exceptions), a failure counter increases.
- Once the number of failures exceeds a predefined threshold, the circuit breaker opens.
Open:
- In the open state, the circuit breaker blocks requests to the external service for a certain period (also called the timeout period).
- The purpose of the open state is to prevent overwhelming a service that is already failing, thus allowing it time to recover.
- During this period, failures are returned immediately without calling the external service.
Half-Open:
- After the timeout period, the circuit breaker moves to the half-open state, where it allows a limited number of test requests to see if the external service has recovered.
- If the test requests succeed, the circuit breaker closes, and normal traffic resumes.
- If the test requests fail, the circuit breaker returns to the open state.

Circuit Breaker Workflow

Initial State – Closed:
- Requests to the external service are allowed.
- If a certain number of requests fail (e.g., 5 consecutive failures), the circuit breaker transitions to the open state.
Open State:
- Requests to the external service are blocked and fail immediately, preventing further load on the failing service.
- After a predefined period (e.g., 30 seconds), the circuit breaker transitions to the half-open state.
Half-Open State:
- A small number of requests are allowed to test if the external service has recovered.
- If the requests succeed, the circuit breaker returns to the closed state.
- If the requests fail, the circuit breaker goes back to the open state.

Example Use Case

Let’s say you have two microservices: Order Service and Payment Service. The Order Service depends on the Payment Service to complete an order. If the Payment Service is down or unresponsive, the Order Service could fail to process orders, leading to a bad user experience.

With a Circuit Breaker in place:

If the Payment Service starts failing, the circuit breaker will detect the failures and open the circuit, preventing further calls to the Payment Service.
While the circuit breaker is open, the Order Service might either return a fallback response or inform the user that the payment system is temporarily unavailable.
After a predefined timeout, the circuit breaker will allow a few requests (half-open state) to check if the Payment Service has recovered.
If the Payment Service recovers, normal operation resumes.

Example with Resilience4j

One of the popular libraries for implementing the Circuit Breaker pattern in Spring Boot applications is Resilience4j.

Here’s how you can configure a circuit breaker in Spring Boot using Resilience4j:

Step 1: Add Dependencies

Add the following dependency to your pom.xml file:

&lt;dependency&gt;
    &lt;groupId&gt;io.github.resilience4j&lt;/groupId&gt;
    &lt;artifactId&gt;resilience4j-spring-boot2&lt;/artifactId&gt;
    &lt;version&gt;1.7.0&lt;/version&gt;
&lt;/dependency&gt;

<groupId>io.github.resilience4j</groupId>

<artifactId>resilience4j-spring-boot2</artifactId>

</dependency>

Step 2: Enable Circuit Breaker

In your service class, wrap the call to the external service with a circuit breaker:

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class PaymentService {

    private final RestTemplate restTemplate;

    public PaymentService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
    public String makePayment() {
        // Call the external payment service
        return restTemplate.getForObject("http://payment-service/api/pay", String.class);
    }

    // Fallback method in case the circuit breaker is open or call fails
    public String paymentFallback(Throwable throwable) {
        return "Payment service is currently unavailable. Please try again later.";
    }
}

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;

import org.springframework.stereotype.Service;

import org.springframework.web.client.RestTemplate;

@Service

public class PaymentService {

private final RestTemplate restTemplate;

public PaymentService(RestTemplate restTemplate) {

this.restTemplate = restTemplate;

}

@CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")

public String makePayment() {

// Call the external payment service

return restTemplate.getForObject("http://payment-service/api/pay", String.class);

}

// Fallback method in case the circuit breaker is open or call fails

public String paymentFallback(Throwable throwable) {

return "Payment service is currently unavailable. Please try again later.";

}

Step 3: Configure the Circuit Breaker

You can configure the circuit breaker properties in your application.yml file:

resilience4j:
  circuitbreaker:
    instances:
      paymentService:
        registerHealthIndicator: true
        ringBufferSizeInClosedState: 5
        ringBufferSizeInHalfOpenState: 3
        waitDurationInOpenState: 10000  # Time the circuit breaker will stay open (in milliseconds)
        failureRateThreshold: 50  # Percentage of failures to open the circuit breaker

resilience4j:

circuitbreaker:

instances:

paymentService:

registerHealthIndicator: true

ringBufferSizeInClosedState: 5

ringBufferSizeInHalfOpenState: 3

waitDurationInOpenState: 10000 # Time the circuit breaker will stay open (in milliseconds)

failureRateThreshold: 50 # Percentage of failures to open the circuit breaker

Step 4: Circuit Breaker Dashboard (Optional)

You can also enable metrics and monitoring for your circuit breakers using Spring Boot Actuator and Micrometer to track the state of your circuit breakers in real-time.

Benefits of the Circuit Breaker Pattern:

Prevents Cascading Failures: It protects the entire system from being brought down by a single failing service.
Increased Fault Tolerance: By temporarily stopping requests to a failing service, it allows the service to recover without being overwhelmed.
Faster Failures: When a service is down, the circuit breaker returns failures instantly instead of waiting for timeouts, improving the user experience.
Graceful Degradation: With fallback methods, the system can degrade gracefully, still providing some functionality even when parts of the system are failing.

Challenges

Determining Circuit Breaker Configuration: Choosing the right thresholds (e.g., failure rate, timeout duration, wait duration) can be tricky and may require tuning based on the system’s behavior.
Fallback Logic: Writing effective fallback methods is crucial, as they are responsible for returning meaningful responses when services fail.

Summary

The Circuit Breaker pattern is an essential tool for building resilient microservices. It allows your application to gracefully handle service failures, avoid overloading struggling services, and maintain overall system stability by controlling how failures are propagated across the system. This pattern is commonly used in conjunction with libraries like Resilience4j or Hystrix in the Java ecosystem, ensuring fault tolerance and resilience in distributed systems.