API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) · 강의

Resilience4j를 사용한 회로 차단기

Resilience4j를 연동하여 회로 차단기 패턴을 구현하고 마이크로서비스의 연쇄 장애를 방지해 보세요.

Resilience4j를 사용한 회로 차단기은(는) CoddyKit의 무료 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 강의입니다. 이것은 4개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Microservices & Resilience

In a microservices architecture, many small services work together. While powerful, this interconnectedness can be a weakness.

If one service becomes slow or unresponsive, requests can pile up, leading to other services waiting, which then slows them down too. This is called a cascading failure and can bring down your entire system!

What's a Circuit Breaker?

Think of an electrical circuit breaker in your home. If there's an overload, it 'trips' to prevent damage.

In software, a Circuit Breaker pattern does the same. It stops continuous calls to a failing service, giving that service time to recover and preventing the failure from spreading.

Instead of hammering a broken service, the circuit breaker 'fails fast' by immediately returning an error or a fallback response.

Introducing Resilience4j

Resilience4j is a lightweight, fault-tolerance library inspired by Netflix Hystrix. It's designed for functional programming and integrates seamlessly with Spring Boot.

It provides various resilience patterns, including Circuit Breaker, Rate Limiter, Retry, and Bulkhead, helping you build more robust microservices.

The Three States of a Circuit

A Circuit Breaker operates in three main states:

CLOSED: This is the normal state. Requests pass through to the protected service. If failures exceed a configured threshold, it transitions to OPEN.
OPEN: No requests are allowed through. All calls fail immediately. After a configured wait duration, it transitions to HALF_OPEN.
HALF_OPEN: A limited number of test requests are allowed. If these succeed, the circuit CLOSEs. If they fail, it re-OPENs.

Setting Up Resilience4j

To use Resilience4j with Spring Boot, you need to add the necessary dependencies to your pom.xml (for Maven) or build.gradle (for Gradle).

These dependencies provide the core Circuit Breaker functionality and Spring Boot integration.

<!-- Maven (pom.xml) -->
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>1.7.1</version>
</dependency>
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-circuitbreaker</artifactId>
    <version>1.7.1</version>
</dependency>

Basic Circuit Breaker Config

You configure Circuit Breakers in your application.yml or application.properties. Here's a basic example:

failureRateThreshold: Percentage of failures to open the circuit.
waitDurationInOpenState: How long the circuit stays open.
slidingWindowSize: Number of calls to consider for failure rate.

resilience4j.circuitbreaker:
  instances:
    myBackendService:
      failureRateThreshold: 50
      waitDurationInOpenState: 5s
      slidingWindowType: COUNT_BASED
      slidingWindowSize: 10

Protecting a Service Call

With Spring Boot, you can easily apply a Circuit Breaker using the @CircuitBreaker annotation on the method you want to protect.

Specify the name of your configured circuit breaker instance and an optional fallbackMethod.

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

@Service
public class MyExternalService {

    @CircuitBreaker(name = "myBackendService", fallbackMethod = "reliableFallback")
    public String callReliableApi() {
        // Simulate an API call that might fail
        if (Math.random() < 0.7) {
            throw new RuntimeException("API call failed!");
        }
        return "Data from API";
    }

    public String reliableFallback(Throwable t) {
        return "Fallback: Service is currently unavailable.";
    }
}

Hands-on with Resilience4j

Let's see a Circuit Breaker in action! This runnable example simulates calls to a service that frequently fails, demonstrating the state transitions.

Observe how the circuit opens after several failures and then tries to half-open after a delay.

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.vavr.CheckedFunction0;
import java.time.Duration;

public class Main {
    public static void main(String[] args) {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50) // 50% failure rate to open
            .waitDurationInOpenState(Duration.ofSeconds(2))
            .slidingWindowSize(10)
            .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.COUNT_BASED)
            .build();

        CircuitBreaker circuitBreaker = CircuitBreaker.of("myTestService", config);

        circuitBreaker.getEventPublisher()
            .onStateTransition(event -> System.out.println("\nCircuit Breaker State Transition: " + event.getOldState() + " -> " + event.getNewState() + "\n"));

        System.out.println("Simulating 20 service calls...");
        for (int i = 1; i <= 20; i++) {
            try {
                String result = circuitBreaker.executeCheckedSupplier(
                    (CheckedFunction0<String>) () -> {
                        if (Math.random() < 0.6) { // Simulate 60% failure
                            System.out.println("  Call " + i + ": Service failed!");
                            throw new RuntimeException("Simulated Service Error");
                        }
                        System.out.println("  Call " + i + ": Service succeeded.");
                        return "Data from Service";
                    });
                System.out.println("  -> Result: " + result);
            } catch (Throwable t) {
                System.out.println("  -> Result: Fallback/Circuit OPEN! Message: " + t.getMessage());
            }
            try {
                Thread.sleep(200); // Pause to observe behavior
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("\nSimulation complete. Final state: " + circuitBreaker.getState());
    }
}

Handling Fallbacks Gracefully

The fallbackMethod is crucial. When the protected method fails (either due to an exception or the circuit being OPEN), this method is invoked instead.

It allows you to provide a default response, cached data, or a simplified experience to the user, preventing a complete failure of the user's request.

Always ensure your fallback method has the same return type and accepts a Throwable as its last argument.

Key Configuration Parameters

Understanding these parameters helps you fine-tune your Circuit Breaker:

failureRateThreshold: The percentage of failures that will cause the circuit to open.
waitDurationInOpenState: The duration the circuit will stay in the OPEN state before transitioning to HALF_OPEN.
slidingWindowSize: The number of calls that are recorded and used to calculate the failure rate.
slidingWindowType: Can be COUNT_BASED (a fixed number of calls) or TIME_BASED (calls within a certain time window).

Quick Check: Circuit States

Which of the following conditions might cause a Circuit Breaker to transition from CLOSED to OPEN state in Resilience4j?

Recap: Guarding Your Services

You've learned that Circuit Breakers are an essential pattern for building resilient microservices. They prevent cascading failures by 'tripping' when a service is unhealthy, giving it time to recover.

Resilience4j provides a lightweight and powerful way to implement these patterns in your Spring Cloud Gateway or Spring Boot applications. You now understand its states, basic configuration, and how to apply it to protect your services.

자주 묻는 질문

“Resilience4j를 사용한 회로 차단기” 강의는 무료인가요?

네 — “Resilience4j를 사용한 회로 차단기” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 강의 전체를 잠금 해제할 수 있습니다. API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 강의에는 총 4개의 강의가 포함되어 있습니다.

“Resilience4j를 사용한 회로 차단기”에서 뭘 배우나요?

Resilience4j를 연동하여 회로 차단기 패턴을 구현하고 마이크로서비스의 연쇄 장애를 방지해 보세요. 브라우저에서 직접 실행하는 실습 코드로 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 1번째 강의입니다.

“Resilience4j를 사용한 회로 차단기” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway) 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← API Gateway & Reverse Proxy (Nginx + Spring Cloud Gateway)(으)로 돌아가기