Microservices Communication Patterns (Saga, Circuit Breaker) · 강의

대체 처리 및 시간 초과 구현

서비스를 사용할 수 없거나 응답이 느린 상황을 원활하게 처리하도록 대체 처리 메커니즘과 시간 초과를 구현하는 방법을 살펴봅니다.

대체 처리 및 시간 초과 구현은(는) CoddyKit의 무료 Microservices Communication Patterns (Saga, Circuit Breaker) 강의입니다. 이것은 4개 중 3번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Microservices Communication Patterns (Saga, Circuit Breaker) 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Microservices Communication Patterns (Saga, Circuit Breaker) 강의에는 총 4개의 강의가 포함되어 있습니다.

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

Welcome to Resilience Patterns

In this lesson, we'll dive into two crucial patterns for building resilient microservices: Fallbacks and Timeouts.

These patterns help your applications gracefully handle failures and slow responses from other services, making your system more robust and reliable.

What is a Fallback?

A fallback mechanism provides an alternative course of action when a primary operation fails or encounters an error.

It ensures your application can still respond, even if partially, instead of completely failing.
Think of it as a plan B for your service calls.
This leads to graceful degradation, where the system provides reduced functionality rather than total failure.

Fallback in Action: Default Data

Imagine an e-commerce site. If the service providing personalized product recommendations fails, you wouldn't want the entire page to break.

A fallback could display:

Popular items (default list)
Cached recommendations
A simple message like 'Recommendations currently unavailable'

The user experience remains intact, even with a minor issue.

Coding a Simple Fallback

Let's see a basic Java example. Here, if our 'external service' throws an error, we catch it and return a default value instead of letting the application crash.

public class FallbackExample {

  public String getProductRecommendation() {
    try {
      // Simulate calling an external service that might fail
      if (Math.random() < 0.5) {
        throw new RuntimeException("Service unavailable!");
      }
      return "Personalized Recommendation A";
    } catch (Exception e) {
      // Fallback: return a default recommendation
      System.out.println("Fallback activated: " + e.getMessage());
      return "Default Popular Product";
    }
  }

  public static void main(String[] args) {
    FallbackExample app = new FallbackExample();
    System.out.println("Recommendation: " + app.getProductRecommendation());
    System.out.println("Recommendation: " + app.getProductRecommendation());
  }
}

Why Do We Need Timeouts?

While fallbacks handle failures, timeouts address slow responses. A service might not fail outright, but it could take too long to respond.

Resource Exhaustion: Waiting indefinitely ties up resources (threads, connections).
Cascading Failures: A slow service can make other dependent services slow, leading to a system-wide slowdown.

Timeouts set a maximum duration for an operation.

Types of Timeouts

When making network calls, you'll often encounter different types of timeouts:

Connection Timeout: The maximum time allowed to establish a connection to the remote service. If no connection is made within this time, it fails.
Read Timeout: The maximum time allowed for data to be received after the connection is established. If the service stops sending data, this timeout triggers.
Request Timeout: An overall timeout for the entire operation, from start to finish. This often encompasses both connection and read timeouts.

Setting a Request Timeout

In Java, setting timeouts depends on the client library you're using (e.g., OkHttp, HttpClient). Conceptually, it looks like this:

HttpClient client = HttpClient.newBuilder()
  .connectTimeout(Duration.ofSeconds(5))
  .build();

HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("http://slowservice.com/data"))
  .timeout(Duration.ofSeconds(10)) // Request timeout
  .GET()
  .build();

This ensures your request won't hang forever.

Combining Timeout & Fallback

Timeouts and fallbacks are powerful when used together. A timeout triggers a failure, which can then be handled by a fallback.

Let's extend our previous example. We'll simulate a slow service call. If it takes too long, a timeout will occur, and our fallback will provide a default response.

import java.util.concurrent.*;

public class TimeoutFallbackExample {

  public String getProductRecommendationWithTimeout() {
    ExecutorService executor = Executors.newSingleThreadExecutor();
    try {
      Future<String> future = executor.submit(() -> {
        // Simulate a slow external service
        long delay = (long) (Math.random() * 3000) + 1000; // 1-4 seconds
        Thread.sleep(delay);
        return "Personalized Recommendation B";
      });

      // Wait for the result, but only for 2 seconds
      return future.get(2, TimeUnit.SECONDS);

    } catch (TimeoutException e) {
      System.out.println("Timeout occurred: " + e.getMessage());
      return "Fallback: Timed out default product";
    } catch (Exception e) {
      System.out.println("Other error: " + e.getMessage());
      return "Fallback: Error default product";
    } finally {
      executor.shutdown();
    }
  }

  public static void main(String[] args) {
    TimeoutFallbackExample app = new TimeoutFallbackExample();
    System.out.println("Recommendation: " + app.getProductRecommendationWithTimeout());
    System.out.println("Recommendation: " + app.getProductRecommendationWithTimeout());
  }
}

Benefits of Using Both

By combining timeouts and fallbacks, you achieve a higher level of resilience:

Improved User Experience: Users don't wait indefinitely for a page to load or an operation to complete.
Resource Protection: Your services don't exhaust resources waiting for unresponsive dependencies.
System Stability: Prevents cascading failures, where one slow service brings down many others.
Predictable Behavior: Your system behaves predictably even under stress.

Quick Check: Resilience

You are designing a microservice that calls an external payment gateway. If the gateway is slow or unavailable, you want to:

Prevent your service from hanging indefinitely.
Show a 'Payment currently unavailable' message to the user instead of an error page.

Which resilience patterns should you prioritize for this scenario?

Recap: Fallbacks & Timeouts

Great job! You've learned about two essential resilience patterns:

Fallbacks: Provide alternative responses to gracefully handle failures, ensuring a better user experience.
Timeouts: Set limits on how long an operation can take, preventing resource exhaustion and cascading failures from slow services.

Using these patterns together makes your microservices more robust and reliable.

자주 묻는 질문

“대체 처리 및 시간 초과 구현” 강의는 무료인가요?

네 — “대체 처리 및 시간 초과 구현” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Microservices Communication Patterns (Saga, Circuit Breaker) 강의 전체를 잠금 해제할 수 있습니다. Microservices Communication Patterns (Saga, Circuit Breaker) 강의에는 총 4개의 강의가 포함되어 있습니다.

“대체 처리 및 시간 초과 구현”에서 뭘 배우나요?

서비스를 사용할 수 없거나 응답이 느린 상황을 원활하게 처리하도록 대체 처리 메커니즘과 시간 초과를 구현하는 방법을 살펴봅니다. 브라우저에서 직접 실행하는 실습 코드로 Microservices Communication Patterns (Saga, Circuit Breaker)을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Microservices Communication Patterns (Saga, Circuit Breaker)을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Microservices Communication Patterns (Saga, Circuit Breaker)은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 3번째 강의입니다.

“대체 처리 및 시간 초과 구현” 강의는 얼마나 걸리나요?

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

이 Microservices Communication Patterns (Saga, Circuit Breaker) 강의에서 코드를 작성하고 실행할 수 있나요?

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

이 강의의 모든 강의

← Microservices Communication Patterns (Saga, Circuit Breaker)(으)로 돌아가기