์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿ›ก๏ธ Polly๋กœ ๊ตฌํ˜„ํ•˜๋Š” ๋ณต์›๋ ฅ ํŒจํ„ด๊ณผ ์žฅ์•  ๋Œ€์‘ ์ „๋žต ์™„๋ฒฝ ๊ฐ€์ด๋“œ

๐Ÿ›ก๏ธ Polly๋กœ ๊ตฌํ˜„ํ•˜๋Š” ๋ณต์›๋ ฅ ํŒจํ„ด๊ณผ ์žฅ์•  ๋Œ€์‘ ์ „๋žต ์™„๋ฒฝ ๊ฐ€์ด๋“œ

C# ๊ฐœ๋ฐœ์ž๋ฅผ ์œ„ํ•œ ์‹ค์ „ ์žฅ์•  ์ฒ˜๋ฆฌ ๊ธฐ๋ฒ• ๐Ÿ’ช

์•ˆ๋…•! ์˜ค๋Š˜์€ C# ๊ฐœ๋ฐœ์ž๋ผ๋ฉด ๊ผญ ์•Œ์•„์•ผ ํ•  Polly ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•ด๋ณผ๊ฒŒ. ํ˜น์‹œ ๋„คํŠธ์›Œํฌ ์š”์ฒญ์ด ์‹คํŒจํ–ˆ์„ ๋•Œ, ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์—ฐ๊ฒฐ์ด ๋Š๊ฒผ์„ ๋•Œ, ์™ธ๋ถ€ API๊ฐ€ ์‘๋‹ตํ•˜์ง€ ์•Š์„ ๋•Œ ์–ด๋–ป๊ฒŒ ๋Œ€์‘ํ•˜๊ณ  ์žˆ์–ด? ๐Ÿค”

"์—๋Ÿฌ ๋‚˜๋ฉด ๊ทธ๋ƒฅ try-catch๋กœ ์žก์œผ๋ฉด ๋˜๋Š” ๊ฑฐ ์•„๋‹ˆ์•ผ?"๋ผ๊ณ  ์ƒ๊ฐํ•  ์ˆ˜๋„ ์žˆ์ง€. ํ•˜์ง€๋งŒ ์‹ค์ œ ํ”„๋กœ๋•์…˜ ํ™˜๊ฒฝ์—์„œ๋Š” ํ›จ์”ฌ ๋” ์ •๊ตํ•œ ์žฅ์•  ๋Œ€์‘ ์ „๋žต์ด ํ•„์š”ํ•ด. ๋ฐ”๋กœ ์—ฌ๊ธฐ์„œ Polly๊ฐ€ ๋น›์„ ๋ฐœํ•˜๋Š” ๊ฑฐ์•ผ! โœจ

๐ŸŽฏ Polly๊ฐ€ ๋ญ๊ธธ๋ž˜?

Polly๋Š” .NET์šฉ ๋ณต์›๋ ฅ(Resilience)๊ณผ ์ผ์‹œ์  ์žฅ์•  ์ฒ˜๋ฆฌ(Transient Fault Handling) ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์•ผ. ๊ฐ„๋‹จํžˆ ๋งํ•˜๋ฉด, ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์ด ์˜ˆ์ƒ์น˜ ๋ชปํ•œ ์˜ค๋ฅ˜๋‚˜ ์žฅ์•  ์ƒํ™ฉ์—์„œ๋„ ์šฐ์•„ํ•˜๊ฒŒ ๋Œ€์‘ํ•  ์ˆ˜ ์žˆ๋„๋ก ๋„์™€์ฃผ๋Š” ๋„๊ตฌ๋ผ๊ณ  ์ƒ๊ฐํ•˜๋ฉด ๋ผ.

๋งˆ์ดํฌ๋กœ์†Œํ”„ํŠธ๋„ ๊ณต์‹์ ์œผ๋กœ ์ถ”์ฒœํ•˜๋Š” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์ด๊ณ , .NET Core์™€ .NET Framework ๋ชจ๋‘์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์–ด. NuGet ํŒจํ‚ค์ง€๋กœ ์‰ฝ๊ฒŒ ์„ค์น˜ํ•  ์ˆ˜ ์žˆ๊ณ , ์‚ฌ์šฉ๋ฒ•๋„ ์ง๊ด€์ ์ด๋ผ ๊ธˆ๋ฐฉ ์ตํž ์ˆ˜ ์žˆ์–ด! ๐Ÿš€

๐Ÿ’ก ์™œ Polly๊ฐ€ ํ•„์š”ํ• ๊นŒ? ํ˜„๋Œ€ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์€ ์ˆ˜๋งŽ์€ ์™ธ๋ถ€ ์„œ๋น„์Šค์™€ ํ†ต์‹ ํ•ด. API ํ˜ธ์ถœ, ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์ฟผ๋ฆฌ, ๋ฉ”์‹œ์ง€ ํ, ์บ์‹œ ์„œ๋ฒ„ ๋“ฑ๋“ฑ... ์ด๋Ÿฐ ์™ธ๋ถ€ ์˜์กด์„ฑ๋“ค์€ ์–ธ์ œ๋“  ์‹คํŒจํ•  ์ˆ˜ ์žˆ์–ด. ๋„คํŠธ์›Œํฌ ์ง€์—ฐ, ์„œ๋ฒ„ ๊ณผ๋ถ€ํ•˜, ์ผ์‹œ์ ์ธ ์žฅ์•  ๋“ฑ ๋‹ค์–‘ํ•œ ์ด์œ ๋กœ ๋ง์ด์•ผ.

Polly๋Š” ์ด๋Ÿฐ ์ƒํ™ฉ์—์„œ ์ž๋™์œผ๋กœ ์žฌ์‹œ๋„ํ•˜๊ฑฐ๋‚˜, ์„œํ‚ท์„ ์ฐจ๋‹จํ•˜๊ฑฐ๋‚˜, ํƒ€์ž„์•„์›ƒ์„ ์„ค์ •ํ•˜๋Š” ๋“ฑ์˜ ์ „๋žต์„ ์‰ฝ๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ค˜!

๐Ÿ”ง Polly ์‹œ์ž‘ํ•˜๊ธฐ

๋จผ์ € NuGet ํŒจํ‚ค์ง€๋ฅผ ์„ค์น˜ํ•ด์•ผ ํ•ด. Visual Studio์˜ ํŒจํ‚ค์ง€ ๊ด€๋ฆฌ์ž ์ฝ˜์†”์—์„œ ๋‹ค์Œ ๋ช…๋ น์–ด๋ฅผ ์‹คํ–‰ํ•˜๋ฉด ๋ผ:

Install-Package Polly
Install-Package Polly.Extensions.Http  // HTTP ํด๋ผ์ด์–ธํŠธ์šฉ

๋˜๋Š” .NET CLI๋ฅผ ์‚ฌ์šฉํ•œ๋‹ค๋ฉด:

dotnet add package Polly
dotnet add package Polly.Extensions.Http

์„ค์น˜๊ฐ€ ์™„๋ฃŒ๋˜๋ฉด ๋ฐ”๋กœ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ˜Š

๐ŸŽจ Polly์˜ ํ•ต์‹ฌ ํŒจํ„ด๋“ค

Polly๋Š” ์—ฌ๋Ÿฌ ๊ฐ€์ง€ ๋ณต์›๋ ฅ ํŒจํ„ด์„ ์ œ๊ณตํ•ด. ํ•˜๋‚˜์”ฉ ์ž์„ธํžˆ ์•Œ์•„๋ณด์ž!

1๏ธโƒฃ Retry ํŒจํ„ด (์žฌ์‹œ๋„)

๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ด๋ฉด์„œ๋„ ๊ฐ•๋ ฅํ•œ ํŒจํ„ด์ด์•ผ. ์ž‘์—…์ด ์‹คํŒจํ•˜๋ฉด ์ž๋™์œผ๋กœ ๋‹ค์‹œ ์‹œ๋„ํ•˜๋Š” ๊ฑฐ์ง€. ์ผ์‹œ์ ์ธ ๋„คํŠธ์›Œํฌ ๋ฌธ์ œ๋‚˜ ์„œ๋ฒ„ ๊ณผ๋ถ€ํ•˜ ๊ฐ™์€ ์ƒํ™ฉ์—์„œ ํŠนํžˆ ์œ ์šฉํ•ด!

// ๊ธฐ๋ณธ์ ์ธ ์žฌ์‹œ๋„ ํŒจํ„ด
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .Retry(3);  // 3๋ฒˆ ์žฌ์‹œ๋„

// ์‚ฌ์šฉ ์˜ˆ์‹œ
retryPolicy.Execute(() => 
{
    // ์‹คํŒจํ•  ์ˆ˜ ์žˆ๋Š” ์ž‘์—…
    var response = httpClient.GetAsync("https://api.example.com/data").Result;
    return response;
});

ํ•˜์ง€๋งŒ ์ด๋ ‡๊ฒŒ๋งŒ ํ•˜๋ฉด ๋„ˆ๋ฌด ๋‹จ์ˆœํ•˜์ง€? ์‹ค์ „์—์„œ๋Š” ๋” ์ •๊ตํ•œ ์„ค์ •์ด ํ•„์š”ํ•ด:

// ์ง€์ˆ˜ ๋ฐฑ์˜คํ”„(Exponential Backoff)๋ฅผ ์‚ฌ์šฉํ•œ ์žฌ์‹œ๋„
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 5,
        sleepDurationProvider: retryAttempt => 
            TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),  // 2, 4, 8, 16, 32์ดˆ
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            // ๋กœ๊น…
            Console.WriteLine($"์žฌ์‹œ๋„ {retryCount}ํšŒ - {timeSpan.TotalSeconds}์ดˆ ๋Œ€๊ธฐ");
        }
    );
๐ŸŽ“ ์ง€์ˆ˜ ๋ฐฑ์˜คํ”„(Exponential Backoff)๋ž€? ์žฌ์‹œ๋„ํ•  ๋•Œ๋งˆ๋‹ค ๋Œ€๊ธฐ ์‹œ๊ฐ„์„ ์ง€์ˆ˜์ ์œผ๋กœ ๋Š˜๋ฆฌ๋Š” ์ „๋žต์ด์•ผ. ์ฒซ ๋ฒˆ์งธ ์žฌ์‹œ๋„๋Š” 2์ดˆ ๋Œ€๊ธฐ, ๋‘ ๋ฒˆ์งธ๋Š” 4์ดˆ, ์„ธ ๋ฒˆ์งธ๋Š” 8์ดˆ... ์ด๋Ÿฐ ์‹์œผ๋กœ ๋ง์ด์•ผ.

์™œ ์ด๋ ‡๊ฒŒ ํ• ๊นŒ? ์„œ๋ฒ„๊ฐ€ ๊ณผ๋ถ€ํ•˜ ์ƒํƒœ์ผ ๋•Œ ์ฆ‰์‹œ ์žฌ์‹œ๋„ํ•˜๋ฉด ์ƒํ™ฉ์„ ๋” ์•…ํ™”์‹œํ‚ฌ ์ˆ˜ ์žˆ๊ฑฐ๋“ . ์‹œ๊ฐ„์„ ๋‘๊ณ  ์žฌ์‹œ๋„ํ•˜๋ฉด ์„œ๋ฒ„๊ฐ€ ํšŒ๋ณตํ•  ์‹œ๊ฐ„์„ ์ฃผ๋Š” ๊ฑฐ์ง€! ๐Ÿ•

2๏ธโƒฃ Circuit Breaker ํŒจํ„ด (ํšŒ๋กœ ์ฐจ๋‹จ๊ธฐ)

์ด๊ฑด ์ •๋ง ๋ฉ‹์ง„ ํŒจํ„ด์ด์•ผ! ์ „๊ธฐ ํšŒ๋กœ์˜ ์ฐจ๋‹จ๊ธฐ์ฒ˜๋Ÿผ ์ž‘๋™ํ•ด์„œ ์ด๋Ÿฐ ์ด๋ฆ„์ด ๋ถ™์—ˆ์–ด. ๐Ÿ”Œ

์„œ๋น„์Šค๊ฐ€ ๊ณ„์† ์‹คํŒจํ•˜๋ฉด, ์ผ์ • ์‹œ๊ฐ„ ๋™์•ˆ ์•„์˜ˆ ์š”์ฒญ์„ ๋ณด๋‚ด์ง€ ์•Š๊ณ  ์ฆ‰์‹œ ์‹คํŒจ ์ฒ˜๋ฆฌ๋ฅผ ํ•ด. ์™œ ๊ทธ๋Ÿด๊นŒ? ์ด๋ฏธ ์ฃฝ์–ด์žˆ๋Š” ์„œ๋น„์Šค์— ๊ณ„์† ์š”์ฒญ์„ ๋ณด๋‚ด๋ดค์ž ๋ฆฌ์†Œ์Šค๋งŒ ๋‚ญ๋น„๋˜๊ณ , ์‘๋‹ต ์‹œ๊ฐ„๋งŒ ๊ธธ์–ด์ง€๊ฑฐ๋“ !

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 3,  // 3๋ฒˆ ์‹คํŒจํ•˜๋ฉด
        durationOfBreak: TimeSpan.FromMinutes(1),  // 1๋ถ„๊ฐ„ ์ฐจ๋‹จ
        onBreak: (exception, duration) =>
        {
            Console.WriteLine($"ํšŒ๋กœ ์ฐจ๋‹จ! {duration.TotalSeconds}์ดˆ๊ฐ„ ๋Œ€๊ธฐ");
        },
        onReset: () =>
        {
            Console.WriteLine("ํšŒ๋กœ ๋ณต๊ตฌ๋จ!");
        },
        onHalfOpen: () =>
        {
            Console.WriteLine("ํšŒ๋กœ ๋ฐ˜๊ฐœ๋ฐฉ - ํ…Œ์ŠคํŠธ ์š”์ฒญ ์‹œ๋„");
        }
    );
Circuit Breaker ์ƒํƒœ ์ „ํ™˜ Closed ์ •์ƒ ์ž‘๋™ Open ํšŒ๋กœ ์ฐจ๋‹จ Half-Open ํ…Œ์ŠคํŠธ ์ค‘ ์‹คํŒจ ์ž„๊ณ„๊ฐ’ ์ดˆ๊ณผ ๋Œ€๊ธฐ ์‹œ๊ฐ„ ๊ฒฝ๊ณผ ํ…Œ์ŠคํŠธ ์„ฑ๊ณต ํ…Œ์ŠคํŠธ ์‹คํŒจ
๐Ÿ”„ Circuit Breaker์˜ ์„ธ ๊ฐ€์ง€ ์ƒํƒœ 1. Closed (๋‹ซํž˜): ์ •์ƒ ์ƒํƒœ. ๋ชจ๋“  ์š”์ฒญ์ด ์ •์ƒ์ ์œผ๋กœ ์ฒ˜๋ฆฌ๋ผ.

2. Open (์—ด๋ฆผ): ํšŒ๋กœ ์ฐจ๋‹จ ์ƒํƒœ. ์„ค์ •๋œ ์‹คํŒจ ํšŸ์ˆ˜๋ฅผ ์ดˆ๊ณผํ•˜๋ฉด ์ด ์ƒํƒœ๊ฐ€ ๋˜๊ณ , ๋ชจ๋“  ์š”์ฒญ์ด ์ฆ‰์‹œ ์‹คํŒจ ์ฒ˜๋ฆฌ๋ผ.

3. Half-Open (๋ฐ˜๊ฐœ๋ฐฉ): ํ…Œ์ŠคํŠธ ์ƒํƒœ. ์ผ์ • ์‹œ๊ฐ„์ด ์ง€๋‚˜๋ฉด ์ด ์ƒํƒœ๊ฐ€ ๋˜๊ณ , ๋‹ค์Œ ์š”์ฒญ์œผ๋กœ ์„œ๋น„์Šค๊ฐ€ ๋ณต๊ตฌ๋˜์—ˆ๋Š”์ง€ ํ…Œ์ŠคํŠธํ•ด. ์„ฑ๊ณตํ•˜๋ฉด Closed๋กœ, ์‹คํŒจํ•˜๋ฉด ๋‹ค์‹œ Open์œผ๋กœ ๋Œ์•„๊ฐ€.

3๏ธโƒฃ Timeout ํŒจํ„ด (์‹œ๊ฐ„ ์ œํ•œ)

๋ฌดํ•œ์ • ๊ธฐ๋‹ค๋ฆด ์ˆ˜๋Š” ์—†์ž–์•„? Timeout ํŒจํ„ด์€ ์ž‘์—…์ด ์ผ์ • ์‹œ๊ฐ„ ๋‚ด์— ์™„๋ฃŒ๋˜์ง€ ์•Š์œผ๋ฉด ์ž๋™์œผ๋กœ ์ทจ์†Œ์‹œ์ผœ์ค˜. โฑ๏ธ

var timeoutPolicy = Policy
    .Timeout(TimeSpan.FromSeconds(30), 
        onTimeout: (context, timespan, task) =>
        {
            Console.WriteLine($"ํƒ€์ž„์•„์›ƒ ๋ฐœ์ƒ! {timespan.TotalSeconds}์ดˆ ์ดˆ๊ณผ");
        });

// ์‚ฌ์šฉ
timeoutPolicy.Execute(() => 
{
    // 30์ดˆ ์ด๋‚ด์— ์™„๋ฃŒ๋˜์–ด์•ผ ํ•˜๋Š” ์ž‘์—…
    return LongRunningOperation();
});

4๏ธโƒฃ Fallback ํŒจํ„ด (๋Œ€์ฒด ์ฒ˜๋ฆฌ)

๋ชจ๋“  ์žฌ์‹œ๋„๊ฐ€ ์‹คํŒจํ–ˆ์„ ๋•Œ, ๋Œ€์ฒด ๊ฐ’์ด๋‚˜ ๋Œ€์ฒด ๋™์ž‘์„ ์ œ๊ณตํ•˜๋Š” ํŒจํ„ด์ด์•ผ. ์‚ฌ์šฉ์ž ๊ฒฝํ—˜์„ ํ•ด์น˜์ง€ ์•Š์œผ๋ฉด์„œ ์šฐ์•„ํ•˜๊ฒŒ ์‹คํŒจ๋ฅผ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์–ด! ๐ŸŽญ

var fallbackPolicy = Policy<string>
    .Handle<HttpRequestException>()
    .Fallback(
        fallbackValue: "์บ์‹œ๋œ ๋ฐ์ดํ„ฐ",
        onFallback: (result, context) =>
        {
            Console.WriteLine("Fallback ์‹คํ–‰ - ์บ์‹œ ๋ฐ์ดํ„ฐ ๋ฐ˜ํ™˜");
        }
    );

// ์‚ฌ์šฉ
var result = fallbackPolicy.Execute(() => 
{
    // API ํ˜ธ์ถœ ์‹œ๋„
    return FetchDataFromApi();
});

5๏ธโƒฃ Bulkhead Isolation ํŒจํ„ด (๊ฒฉ๋ฒฝ ๊ฒฉ๋ฆฌ)

๋ฐฐ์˜ ๊ฒฉ๋ฒฝ์ฒ˜๋Ÿผ, ํ•œ ๋ถ€๋ถ„์— ๋ฌธ์ œ๊ฐ€ ์ƒ๊ฒจ๋„ ๋‹ค๋ฅธ ๋ถ€๋ถ„์€ ์˜ํ–ฅ๋ฐ›์ง€ ์•Š๋„๋ก ๋ฆฌ์†Œ์Šค๋ฅผ ๊ฒฉ๋ฆฌํ•˜๋Š” ํŒจํ„ด์ด์•ผ. ๋™์‹œ ์‹คํ–‰ ์ˆ˜๋ฅผ ์ œํ•œํ•ด์„œ ์‹œ์Šคํ…œ ์ „์ฒด๊ฐ€ ๋งˆ๋น„๋˜๋Š” ๊ฑธ ๋ฐฉ์ง€ํ•ด! ๐Ÿšข

var bulkheadPolicy = Policy
    .Bulkhead(
        maxParallelization: 10,  // ์ตœ๋Œ€ 10๊ฐœ ๋™์‹œ ์‹คํ–‰
        maxQueuingActions: 20,   // ์ตœ๋Œ€ 20๊ฐœ ๋Œ€๊ธฐ
        onBulkheadRejected: context =>
        {
            Console.WriteLine("Bulkhead ์šฉ๋Ÿ‰ ์ดˆ๊ณผ - ์š”์ฒญ ๊ฑฐ๋ถ€๋จ");
        }
    );

๐ŸŽช ํŒจํ„ด ์กฐํ•ฉํ•˜๊ธฐ (Policy Wrap)

์—ฌ๊ธฐ์„œ๋ถ€ํ„ฐ๊ฐ€ ์ง„์งœ ์žฌ๋ฏธ์žˆ๋Š” ๋ถ€๋ถ„์ด์•ผ! Polly์˜ ์ง„์ •ํ•œ ํž˜์€ ์—ฌ๋Ÿฌ ํŒจํ„ด์„ ์กฐํ•ฉํ•ด์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฑฐ์•ผ. ๋งˆ์น˜ ๋ ˆ๊ณ  ๋ธ”๋ก์ฒ˜๋Ÿผ ๋ง์ด์ง€! ๐Ÿงฑ

์˜ˆ๋ฅผ ๋“ค์–ด, "์žฌ์‹œ๋„ โ†’ ์„œํ‚ท ๋ธŒ๋ ˆ์ด์ปค โ†’ ํƒ€์ž„์•„์›ƒ" ์ˆœ์„œ๋กœ ์ •์ฑ…์„ ์ ์šฉํ•  ์ˆ˜ ์žˆ์–ด:

// ๊ฐœ๋ณ„ ์ •์ฑ… ์ •์˜
var timeoutPolicy = Policy
    .Timeout(TimeSpan.FromSeconds(10));

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(3, retryAttempt => 
        TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(5, TimeSpan.FromMinutes(1));

// ์ •์ฑ… ์กฐํ•ฉ (์•ˆ์ชฝ์—์„œ ๋ฐ”๊นฅ์ชฝ ์ˆœ์„œ๋กœ ์‹คํ–‰๋จ)
var policyWrap = Policy.Wrap(
    circuitBreakerPolicy,  // ๊ฐ€์žฅ ๋ฐ”๊นฅ์ชฝ
    retryPolicy,           // ์ค‘๊ฐ„
    timeoutPolicy          // ๊ฐ€์žฅ ์•ˆ์ชฝ
);

// ์‚ฌ์šฉ
policyWrap.Execute(() => 
{
    return httpClient.GetAsync("https://api.example.com/data").Result;
});
โš ๏ธ ์ •์ฑ… ์ˆœ์„œ๊ฐ€ ์ค‘์š”ํ•ด! Policy.Wrap์—์„œ ์ •์ฑ…์˜ ์ˆœ์„œ๋Š” ๋งค์šฐ ์ค‘์š”ํ•ด. ์•ˆ์ชฝ์—์„œ ๋ฐ”๊นฅ์ชฝ์œผ๋กœ ์‹คํ–‰๋˜๊ธฐ ๋•Œ๋ฌธ์—, ์œ„ ์˜ˆ์‹œ์—์„œ๋Š”:

1. ๋จผ์ € Timeout์ด ์ ์šฉ๋˜๊ณ 
2. ์‹คํŒจํ•˜๋ฉด Retry๊ฐ€ ์ž‘๋™ํ•˜๊ณ 
3. ๊ณ„์† ์‹คํŒจํ•˜๋ฉด Circuit Breaker๊ฐ€ ํšŒ๋กœ๋ฅผ ์ฐจ๋‹จํ•ด

๋งŒ์•ฝ ์ˆœ์„œ๋ฅผ ๋ฐ”๊พธ๋ฉด ์ „ํ˜€ ๋‹ค๋ฅธ ๋™์ž‘์„ ํ•˜๊ฒŒ ๋ผ. ์˜ˆ๋ฅผ ๋“ค์–ด Circuit Breaker๋ฅผ ๊ฐ€์žฅ ์•ˆ์ชฝ์— ๋‘๋ฉด, ์žฌ์‹œ๋„ํ•  ๋•Œ๋งˆ๋‹ค ํšŒ๋กœ ์ฐจ๋‹จ ์นด์šดํŠธ๊ฐ€ ์ฆ๊ฐ€ํ•˜๊ฒŒ ๋˜์ง€!

๐ŸŒ HttpClient์™€ Polly ํ†ตํ•ฉ

.NET Core 2.1๋ถ€ํ„ฐ๋Š” HttpClientFactory์™€ Polly๋ฅผ ์•„์ฃผ ์‰ฝ๊ฒŒ ํ†ตํ•ฉํ•  ์ˆ˜ ์žˆ์–ด. ์ด๊ฒŒ ์ •๋ง ๊ฒŒ์ž„ ์ฒด์ธ์ €์•ผ! ๐ŸŽฎ

// Startup.cs ๋˜๋Š” Program.cs์—์„œ
services.AddHttpClient("MyApiClient", client =>
{
    client.BaseAddress = new Uri("https://api.example.com");
    client.DefaultRequestHeaders.Add("Accept", "application/json");
})
.AddTransientHttpErrorPolicy(policyBuilder => 
    policyBuilder.WaitAndRetryAsync(3, retryAttempt => 
        TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))))
.AddTransientHttpErrorPolicy(policyBuilder =>
    policyBuilder.CircuitBreakerAsync(5, TimeSpan.FromMinutes(1)));

// ์‚ฌ์šฉํ•  ๋•Œ
public class MyService
{
    private readonly IHttpClientFactory _httpClientFactory;
    
    public MyService(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
    }
    
    public async Task<string> GetDataAsync()
    {
        var client = _httpClientFactory.CreateClient("MyApiClient");
        var response = await client.GetAsync("/data");
        return await response.Content.ReadAsStringAsync();
    }
}

์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์˜์กด์„ฑ ์ฃผ์ž…(DI)์„ ํ†ตํ•ด ๊น”๋”ํ•˜๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๊ณ , ๋ชจ๋“  HTTP ์š”์ฒญ์— ์ž๋™์œผ๋กœ ๋ณต์›๋ ฅ ์ •์ฑ…์ด ์ ์šฉ๋ผ! ๐Ÿ˜Ž

๐Ÿ“Š ์‹ค์ „ ์˜ˆ์ œ: ์™„์ „ํ•œ ๋ณต์›๋ ฅ ์ „๋žต

์ด์ œ ์‹ค์ œ ํ”„๋กœ์ ํŠธ์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ์™„์ „ํ•œ ์˜ˆ์ œ๋ฅผ ๋งŒ๋“ค์–ด๋ณผ๊ฒŒ. ์™ธ๋ถ€ API๋ฅผ ํ˜ธ์ถœํ•˜๋Š” ์„œ๋น„์Šค๋ฅผ ๊ตฌํ˜„ํ•ด๋ณด์ž!

public class ResilientApiService
{
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly ILogger<ResilientApiService> _logger;
    
    public ResilientApiService(
        IHttpClientFactory httpClientFactory,
        ILogger<ResilientApiService> logger)
    {
        _httpClientFactory = httpClientFactory;
        _logger = logger;
    }
    
    public async Task<ApiResponse> GetDataWithResilienceAsync(string endpoint)
    {
        // 1. Timeout ์ •์ฑ…
        var timeoutPolicy = Policy
            .TimeoutAsync<HttpResponseMessage>(
                TimeSpan.FromSeconds(30),
                onTimeoutAsync: async (context, timespan, task) =>
                {
                    _logger.LogWarning($"ํƒ€์ž„์•„์›ƒ ๋ฐœ์ƒ: {endpoint}");
                });
        
        // 2. Retry ์ •์ฑ… (์ง€์ˆ˜ ๋ฐฑ์˜คํ”„)
        var retryPolicy = Policy
            .Handle<HttpRequestException>()
            .Or<TimeoutRejectedException>()
            .WaitAndRetryAsync(
                retryCount: 3,
                sleepDurationProvider: retryAttempt => 
                    TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
                onRetry: (exception, timeSpan, retryCount, context) =>
                {
                    _logger.LogWarning(
                        $"์žฌ์‹œ๋„ {retryCount}ํšŒ - {timeSpan.TotalSeconds}์ดˆ ๋Œ€๊ธฐ. " +
                        $"์˜ˆ์™ธ: {exception.Message}");
                });
        
        // 3. Circuit Breaker ์ •์ฑ…
        var circuitBreakerPolicy = Policy
            .Handle<HttpRequestException>()
            .Or<TimeoutRejectedException>()
            .CircuitBreakerAsync(
                exceptionsAllowedBeforeBreaking: 5,
                durationOfBreak: TimeSpan.FromMinutes(1),
                onBreak: (exception, duration) =>
                {
                    _logger.LogError(
                        $"ํšŒ๋กœ ์ฐจ๋‹จ! {duration.TotalSeconds}์ดˆ๊ฐ„ ๋Œ€๊ธฐ. " +
                        $"์˜ˆ์™ธ: {exception.Message}");
                },
                onReset: () =>
                {
                    _logger.LogInformation("ํšŒ๋กœ ๋ณต๊ตฌ๋จ!");
                },
                onHalfOpen: () =>
                {
                    _logger.LogInformation("ํšŒ๋กœ ๋ฐ˜๊ฐœ๋ฐฉ - ํ…Œ์ŠคํŠธ ์š”์ฒญ ์‹œ๋„");
                });
        
        // 4. Fallback ์ •์ฑ…
        var fallbackPolicy = Policy<ApiResponse>
            .Handle<BrokenCircuitException>()
            .Or<HttpRequestException>()
            .FallbackAsync(
                fallbackValue: new ApiResponse 
                { 
                    Success = false, 
                    Data = null,
                    Message = "์„œ๋น„์Šค ์ผ์‹œ์  ์žฅ์•  - ์บ์‹œ ๋ฐ์ดํ„ฐ ์‚ฌ์šฉ ์ค‘"
                },
                onFallbackAsync: async (result, context) =>
                {
                    _logger.LogWarning("Fallback ์‹คํ–‰ - ๋Œ€์ฒด ์‘๋‹ต ๋ฐ˜ํ™˜");
                    // ์—ฌ๊ธฐ์„œ ์บ์‹œ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ๊ฐ€์ ธ์˜ฌ ์ˆ˜๋„ ์žˆ์Œ
                });
        
        // 5. ์ •์ฑ… ์กฐํ•ฉ
        var policyWrap = Policy.WrapAsync(
            fallbackPolicy,
            circuitBreakerPolicy,
            retryPolicy,
            timeoutPolicy
        );
        
        // 6. ์‹คํ–‰
        return await policyWrap.ExecuteAsync(async () =>
        {
            var client = _httpClientFactory.CreateClient();
            var response = await client.GetAsync(endpoint);
            response.EnsureSuccessStatusCode();
            
            var content = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<ApiResponse>(content);
        });
    }
}

public class ApiResponse
{
    public bool Success { get; set; }
    public object Data { get; set; }
    public string Message { get; set; }
}

์ด ์ฝ”๋“œ๋Š” ์ •๋ง ๊ฐ•๋ ฅํ•ด! ํƒ€์ž„์•„์›ƒ, ์žฌ์‹œ๋„, ์„œํ‚ท ๋ธŒ๋ ˆ์ด์ปค, ํด๋ฐฑ๊นŒ์ง€ ๋ชจ๋“  ๋ณต์›๋ ฅ ํŒจํ„ด์ด ์ ์šฉ๋˜์–ด ์žˆ์–ด. ์‹ค์ œ ํ”„๋กœ๋•์…˜ ํ™˜๊ฒฝ์—์„œ ๋ฐ”๋กœ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ์ˆ˜์ค€์ด์ง€! ๐Ÿ’ช

๐ŸŽฏ Polly v8์˜ ์ƒˆ๋กœ์šด ๊ธฐ๋Šฅ

2023๋…„์— ์ถœ์‹œ๋œ Polly v8์€ ์™„์ „ํžˆ ์ƒˆ๋กญ๊ฒŒ ์žฌ์„ค๊ณ„๋˜์—ˆ์–ด! ๊ธฐ์กด ๋ฒ„์ „๊ณผ ํ˜ธํ™˜์„ฑ์€ ์œ ์ง€ํ•˜๋ฉด์„œ๋„ ๋” ํ˜„๋Œ€์ ์ด๊ณ  ๊ฐ•๋ ฅํ•œ ๊ธฐ๋Šฅ๋“ค์ด ์ถ”๊ฐ€๋˜์—ˆ์ง€. ๐Ÿ†•

ResiliencePipeline - ์ƒˆ๋กœ์šด API

v8์—์„œ๋Š” ResiliencePipeline์ด๋ผ๋Š” ์ƒˆ๋กœ์šด ๊ฐœ๋…์ด ๋„์ž…๋˜์—ˆ์–ด. ๊ธฐ์กด์˜ Policy๋ณด๋‹ค ๋” ์ง๊ด€์ ์ด๊ณ  ์„ฑ๋Šฅ๋„ ์ข‹์•„์กŒ์–ด!

// Polly v8 ๋ฐฉ์‹
var pipeline = new ResiliencePipelineBuilder()
    .AddRetry(new RetryStrategyOptions
    {
        MaxRetryAttempts = 3,
        Delay = TimeSpan.FromSeconds(1),
        BackoffType = DelayBackoffType.Exponential,
        OnRetry = args =>
        {
            Console.WriteLine($"์žฌ์‹œ๋„ {args.AttemptNumber}ํšŒ");
            return default;
        }
    })
    .AddCircuitBreaker(new CircuitBreakerStrategyOptions
    {
        FailureRatio = 0.5,
        SamplingDuration = TimeSpan.FromSeconds(10),
        MinimumThroughput = 5,
        BreakDuration = TimeSpan.FromSeconds(30)
    })
    .AddTimeout(TimeSpan.FromSeconds(10))
    .Build();

// ์‚ฌ์šฉ
var result = await pipeline.ExecuteAsync(async ct => 
{
    return await httpClient.GetAsync("https://api.example.com/data", ct);
}, cancellationToken);
๐Ÿš€ v8์˜ ์ฃผ์š” ๊ฐœ์„ ์‚ฌํ•ญ โ€ข ์„ฑ๋Šฅ ํ–ฅ์ƒ: ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น์ด ํฌ๊ฒŒ ์ค„์–ด๋“ค๊ณ  ์‹คํ–‰ ์†๋„๊ฐ€ ๋นจ๋ผ์กŒ์–ด
โ€ข ํƒ€์ž… ์•ˆ์ •์„ฑ: ์ œ๋„ค๋ฆญ ํƒ€์ž… ์ฒ˜๋ฆฌ๊ฐ€ ๊ฐœ์„ ๋˜์–ด ์ปดํŒŒ์ผ ํƒ€์ž„์— ๋” ๋งŽ์€ ์˜ค๋ฅ˜๋ฅผ ์žก์„ ์ˆ˜ ์žˆ์–ด
โ€ข ํ…”๋ ˆ๋ฉ”ํŠธ๋ฆฌ: OpenTelemetry์™€์˜ ํ†ตํ•ฉ์ด ๊ธฐ๋ณธ์œผ๋กœ ์ œ๊ณต๋ผ
โ€ข ์ทจ์†Œ ํ† ํฐ: CancellationToken ์ง€์›์ด ๋” ์ž์—ฐ์Šค๋Ÿฌ์›Œ์กŒ์–ด
โ€ข ๋น„๋™๊ธฐ ์šฐ์„ : ๋น„๋™๊ธฐ ์ž‘์—…์ด ๊ธฐ๋ณธ์ด ๋˜์—ˆ์–ด

๐Ÿ“ˆ ๋ชจ๋‹ˆํ„ฐ๋ง๊ณผ ๋ฉ”ํŠธ๋ฆญ

๋ณต์›๋ ฅ ํŒจํ„ด์„ ์ ์šฉํ–ˆ๋‹ค๋ฉด, ์‹ค์ œ๋กœ ์–ผ๋งˆ๋‚˜ ์ž˜ ์ž‘๋™ํ•˜๋Š”์ง€ ๋ชจ๋‹ˆํ„ฐ๋งํ•˜๋Š” ๊ฒƒ๋„ ์ค‘์š”ํ•ด! Polly๋Š” ๋‹ค์–‘ํ•œ ์ด๋ฒคํŠธ๋ฅผ ์ œ๊ณตํ•˜๋‹ˆ๊นŒ ์ด๊ฑธ ํ™œ์šฉํ•ด์„œ ๋ฉ”ํŠธ๋ฆญ์„ ์ˆ˜์ง‘ํ•  ์ˆ˜ ์žˆ์–ด. ๐Ÿ“Š

public class PollyMetricsCollector
{
    private readonly ILogger _logger;
    private int _retryCount = 0;
    private int _circuitBreakerOpenCount = 0;
    private int _timeoutCount = 0;
    
    public IAsyncPolicy<HttpResponseMessage> CreateMonitoredPolicy()
    {
        var retryPolicy = Policy
            .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .Or<HttpRequestException>()
            .WaitAndRetryAsync(
                retryCount: 3,
                sleepDurationProvider: retryAttempt => 
                    TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
                onRetry: (outcome, timespan, retryCount, context) =>
                {
                    Interlocked.Increment(ref _retryCount);
                    _logger.LogWarning(
                        $"์žฌ์‹œ๋„ ๋ฐœ์ƒ (์ด {_retryCount}ํšŒ) - " +
                        $"ํ˜„์žฌ ์‹œ๋„: {retryCount}ํšŒ");
                });
        
        var circuitBreakerPolicy = Policy
            .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .Or<HttpRequestException>()
            .CircuitBreakerAsync(
                exceptionsAllowedBeforeBreaking: 5,
                durationOfBreak: TimeSpan.FromMinutes(1),
                onBreak: (outcome, duration) =>
                {
                    Interlocked.Increment(ref _circuitBreakerOpenCount);
                    _logger.LogError(
                        $"ํšŒ๋กœ ์ฐจ๋‹จ ๋ฐœ์ƒ (์ด {_circuitBreakerOpenCount}ํšŒ)");
                },
                onReset: () =>
                {
                    _logger.LogInformation("ํšŒ๋กœ ๋ณต๊ตฌ");
                });
        
        return Policy.WrapAsync(circuitBreakerPolicy, retryPolicy);
    }
    
    public Dictionary<string, int> GetMetrics()
    {
        return new Dictionary<string, int>
        {
            ["RetryCount"] = _retryCount,
            ["CircuitBreakerOpenCount"] = _circuitBreakerOpenCount,
            ["TimeoutCount"] = _timeoutCount
        };
    }
}

์ด๋Ÿฐ ๋ฉ”ํŠธ๋ฆญ๋“ค์„ Prometheus, Grafana, Application Insights ๊ฐ™์€ ๋ชจ๋‹ˆํ„ฐ๋ง ๋„๊ตฌ๋กœ ๋ณด๋‚ด๋ฉด ์‹œ์Šคํ…œ์˜ ๊ฑด๊ฐ• ์ƒํƒœ๋ฅผ ์‹ค์‹œ๊ฐ„์œผ๋กœ ํŒŒ์•…ํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿ”

๐ŸŽ“ ์‹ค์ „ ํŒ๊ณผ ๋ฒ ์ŠคํŠธ ํ”„๋ž™ํ‹ฐ์Šค

์ด์ œ Polly๋ฅผ ์‹ค์ „์—์„œ ํšจ๊ณผ์ ์œผ๋กœ ์‚ฌ์šฉํ•˜๊ธฐ ์œ„ํ•œ ํŒ๋“ค์„ ๊ณต์œ ํ• ๊ฒŒ!

1. ์ •์ฑ…์„ ์‹ฑ๊ธ€ํ†ค์œผ๋กœ ๊ด€๋ฆฌํ•˜๊ธฐ

์ •์ฑ… ๊ฐ์ฒด๋Š” ์Šค๋ ˆ๋“œ ์•ˆ์ „ํ•˜๊ณ  ์žฌ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•ด. ๋งค๋ฒˆ ์ƒˆ๋กœ ๋งŒ๋“ค์ง€ ๋ง๊ณ  ์‹ฑ๊ธ€ํ†ค์œผ๋กœ ๊ด€๋ฆฌํ•˜๋Š” ๊ฒŒ ์ข‹์•„!

public class PolicyRegistry
{
    private static readonly Lazy<IAsyncPolicy> _retryPolicy = 
        new Lazy<IAsyncPolicy>(() => CreateRetryPolicy());
    
    public static IAsyncPolicy RetryPolicy => _retryPolicy.Value;
    
    private static IAsyncPolicy CreateRetryPolicy()
    {
        return Policy
            .Handle<HttpRequestException>()
            .WaitAndRetryAsync(3, retryAttempt => 
                TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
    }
}

2. Context๋ฅผ ํ™œ์šฉํ•œ ์ƒํƒœ ์ „๋‹ฌ

Polly์˜ Context ๊ฐ์ฒด๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์ •์ฑ… ์‹คํ–‰ ์ค‘์— ์ƒํƒœ๋ฅผ ์ „๋‹ฌํ•  ์ˆ˜ ์žˆ์–ด. ๋กœ๊น…์ด๋‚˜ ์ถ”์ ์— ์œ ์šฉํ•˜์ง€!

var context = new Context
{
    ["RequestId"] = Guid.NewGuid().ToString(),
    ["UserId"] = currentUserId,
    ["Endpoint"] = endpoint
};

await retryPolicy.ExecuteAsync(async (ctx) =>
{
    var requestId = ctx["RequestId"];
    _logger.LogInformation($"์š”์ฒญ ์‹คํ–‰: {requestId}");
    return await MakeApiCall();
}, context);

3. ์ ์ ˆํ•œ ํƒ€์ž„์•„์›ƒ ์„ค์ •

ํƒ€์ž„์•„์›ƒ์€ ๋„ˆ๋ฌด ์งง์œผ๋ฉด ์ •์ƒ ์š”์ฒญ๋„ ์‹คํŒจํ•˜๊ณ , ๋„ˆ๋ฌด ๊ธธ๋ฉด ์‚ฌ์šฉ์ž ๊ฒฝํ—˜์ด ๋‚˜๋น ์ ธ. ์‹ค์ œ ์‘๋‹ต ์‹œ๊ฐ„์„ ์ธก์ •ํ•ด์„œ ์ ์ ˆํ•œ ๊ฐ’์„ ์„ค์ •ํ•ด์•ผ ํ•ด!

์ž‘์—… ์œ ํ˜• ๊ถŒ์žฅ ํƒ€์ž„์•„์›ƒ ์„ค๋ช…
๊ฐ„๋‹จํ•œ API ์กฐํšŒ 5-10์ดˆ ๋น ๋ฅธ ์‘๋‹ต์ด ์˜ˆ์ƒ๋˜๋Š” ๊ฒฝ์šฐ
๋ณต์žกํ•œ ์ฟผ๋ฆฌ 30-60์ดˆ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ๊ฐ€ ํ•„์š”ํ•œ ๊ฒฝ์šฐ
ํŒŒ์ผ ์—…๋กœ๋“œ/๋‹ค์šด๋กœ๋“œ 2-5๋ถ„ ํŒŒ์ผ ํฌ๊ธฐ์— ๋”ฐ๋ผ ์กฐ์ •
๋ฐฐ์น˜ ์ฒ˜๋ฆฌ 10-30๋ถ„ ๋Œ€๋Ÿ‰ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ

4. Circuit Breaker ์ž„๊ณ„๊ฐ’ ์„ค์ •

์„œํ‚ท ๋ธŒ๋ ˆ์ด์ปค์˜ ์ž„๊ณ„๊ฐ’์€ ํŠธ๋ž˜ํ”ฝ ํŒจํ„ด์— ๋”ฐ๋ผ ๋‹ฌ๋ผ์ ธ์•ผ ํ•ด. ์ผ๋ฐ˜์ ์ธ ๊ฐ€์ด๋“œ๋ผ์ธ์€:

๐ŸŽฏ Circuit Breaker ์„ค์ • ๊ฐ€์ด๋“œ ์‹คํŒจ ์ž„๊ณ„๊ฐ’: ์ „์ฒด ์š”์ฒญ์˜ 50% ์ด์ƒ ์‹คํŒจํ•˜๋ฉด ์ฐจ๋‹จ
์ตœ์†Œ ์ฒ˜๋ฆฌ๋Ÿ‰: ์ตœ์†Œ 10-20๊ฐœ ์š”์ฒญ ํ›„์— ํŒ๋‹จ
์ฐจ๋‹จ ์‹œ๊ฐ„: 30์ดˆ-2๋ถ„ ์ •๋„๊ฐ€ ์ ๋‹น
์ƒ˜ํ”Œ๋ง ๊ธฐ๊ฐ„: 10-30์ดˆ ๋™์•ˆ์˜ ์š”์ฒญ์„ ๊ธฐ์ค€์œผ๋กœ ํŒ๋‹จ

5. ์žฌ์‹œ๋„ ์ „๋žต ์„ ํƒ

์ƒํ™ฉ์— ๋”ฐ๋ผ ์ ์ ˆํ•œ ์žฌ์‹œ๋„ ์ „๋žต์„ ์„ ํƒํ•ด์•ผ ํ•ด:

// 1. ์ฆ‰์‹œ ์žฌ์‹œ๋„ (๋„คํŠธ์›Œํฌ ์ˆœ๊ฐ„ ๋Š๊น€)
Policy.Handle<HttpRequestException>()
    .Retry(3);

// 2. ๊ณ ์ • ๊ฐ„๊ฒฉ ์žฌ์‹œ๋„ (์ผ์ •ํ•œ ๋ถ€ํ•˜)
Policy.Handle<HttpRequestException>()
    .WaitAndRetry(3, retryAttempt => TimeSpan.FromSeconds(2));

// 3. ์ง€์ˆ˜ ๋ฐฑ์˜คํ”„ (์„œ๋ฒ„ ๊ณผ๋ถ€ํ•˜)
Policy.Handle<HttpRequestException>()
    .WaitAndRetry(5, retryAttempt => 
        TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

// 4. ์ง€ํ„ฐ๋ฅผ ์ถ”๊ฐ€ํ•œ ์ง€์ˆ˜ ๋ฐฑ์˜คํ”„ (๋™์‹œ ์žฌ์‹œ๋„ ๋ฐฉ์ง€)
Policy.Handle<HttpRequestException>()
    .WaitAndRetry(5, retryAttempt => 
    {
        var baseDelay = TimeSpan.FromSeconds(Math.Pow(2, retryAttempt));
        var jitter = TimeSpan.FromMilliseconds(
            new Random().Next(0, 1000));
        return baseDelay + jitter;
    });

๐ŸŒŸ ์žฌ๋Šฅ๋„ท์—์„œ Polly ํ™œ์šฉํ•˜๊ธฐ

์žฌ๋Šฅ๋„ท(https://www.jaenung.net)์ฒ˜๋Ÿผ ๋‹ค์–‘ํ•œ ์‚ฌ์šฉ์ž๊ฐ€ ๋™์‹œ์— ์ ‘์†ํ•˜๋Š” ํ”Œ๋žซํผ์—์„œ๋Š” ์•ˆ์ •์„ฑ์ด ์ •๋ง ์ค‘์š”ํ•ด! ํŠนํžˆ ๊ฒฐ์ œ ์ฒ˜๋ฆฌ, ํŒŒ์ผ ์—…๋กœ๋“œ, ์™ธ๋ถ€ API ์—ฐ๋™ ๊ฐ™์€ ์ค‘์š”ํ•œ ๊ธฐ๋Šฅ๋“ค์€ ๋ฐ˜๋“œ์‹œ ๋ณต์›๋ ฅ ํŒจํ„ด์„ ์ ์šฉํ•ด์•ผ ํ•ด. ๐Ÿ›ก๏ธ

์˜ˆ๋ฅผ ๋“ค์–ด, ์žฌ๋Šฅ๋„ท์—์„œ ์žฌ๋Šฅ ๊ฑฐ๋ž˜๊ฐ€ ์ด๋ฃจ์–ด์งˆ ๋•Œ ๊ฒฐ์ œ ๊ฒŒ์ดํŠธ์›จ์ด์™€ ํ†ต์‹ ํ•˜๋Š” ๋ถ€๋ถ„์— Polly๋ฅผ ์ ์šฉํ•˜๋ฉด:

public class PaymentService
{
    private readonly IAsyncPolicy<PaymentResult> _paymentPolicy;
    
    public PaymentService()
    {
        _paymentPolicy = Policy<PaymentResult>
            .Handle<HttpRequestException>()
            .Or<TimeoutException>()
            .WaitAndRetryAsync(
                retryCount: 3,
                sleepDurationProvider: retryAttempt => 
                    TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
                onRetry: (outcome, timespan, retryCount, context) =>
                {
                    // ์žฌ๋Šฅ๋„ท ๋กœ๊ทธ ์‹œ์Šคํ…œ์— ๊ธฐ๋ก
                    LogPaymentRetry(retryCount, outcome.Exception);
                })
            .WrapAsync(
                Policy<PaymentResult>
                    .Handle<HttpRequestException>()
                    .CircuitBreakerAsync(
                        exceptionsAllowedBeforeBreaking: 5,
                        durationOfBreak: TimeSpan.FromMinutes(1),
                        onBreak: (outcome, duration) =>
                        {
                            // ๊ด€๋ฆฌ์ž์—๊ฒŒ ์•Œ๋ฆผ
                            NotifyAdminPaymentGatewayDown();
                        }
                    )
            );
    }
    
    public async Task<PaymentResult> ProcessPaymentAsync(
        PaymentRequest request)
    {
        return await _paymentPolicy.ExecuteAsync(async () =>
        {
            // ์‹ค์ œ ๊ฒฐ์ œ ์ฒ˜๋ฆฌ
            return await CallPaymentGateway(request);
        });
    }
}

์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์ผ์‹œ์ ์ธ ๋„คํŠธ์›Œํฌ ๋ฌธ์ œ๋กœ ๊ฒฐ์ œ๊ฐ€ ์‹คํŒจํ•˜๋Š” ๊ฒƒ์„ ๋ฐฉ์ง€ํ•  ์ˆ˜ ์žˆ๊ณ , ์‚ฌ์šฉ์ž ๊ฒฝํ—˜๋„ ํฌ๊ฒŒ ๊ฐœ์„ ๋ผ! ๐Ÿ’ณ

๐Ÿ” ๋””๋ฒ„๊น…๊ณผ ๋ฌธ์ œ ํ•ด๊ฒฐ

Polly๋ฅผ ์‚ฌ์šฉํ•˜๋‹ค ๋ณด๋ฉด ๊ฐ€๋” ์˜ˆ์ƒ๊ณผ ๋‹ค๋ฅด๊ฒŒ ๋™์ž‘ํ•  ๋•Œ๊ฐ€ ์žˆ์–ด. ์ด๋Ÿด ๋•Œ ์œ ์šฉํ•œ ๋””๋ฒ„๊น… ํŒ๋“ค์„ ์•Œ๋ ค์ค„๊ฒŒ!

์ƒ์„ธํ•œ ๋กœ๊น… ์ถ”๊ฐ€ํ•˜๊ธฐ

var detailedRetryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: retryAttempt => 
            TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            var requestId = context.ContainsKey("RequestId") 
                ? context["RequestId"] 
                : "Unknown";
            
            _logger.LogWarning(
                "์žฌ์‹œ๋„ ๋ฐœ์ƒ - " +
                "RequestId: {RequestId}, " +
                "์‹œ๋„: {RetryCount}, " +
                "๋Œ€๊ธฐ์‹œ๊ฐ„: {Delay}์ดˆ, " +
                "์˜ˆ์™ธ: {Exception}, " +
                "์ŠคํƒํŠธ๋ ˆ์ด์Šค: {StackTrace}",
                requestId,
                retryCount,
                timeSpan.TotalSeconds,
                exception.Message,
                exception.StackTrace
            );
        }
    );

์ •์ฑ… ๋™์ž‘ ํ…Œ์ŠคํŠธํ•˜๊ธฐ

๋‹จ์œ„ ํ…Œ์ŠคํŠธ๋กœ ์ •์ฑ…์ด ์˜ฌ๋ฐ”๋ฅด๊ฒŒ ๋™์ž‘ํ•˜๋Š”์ง€ ํ™•์ธํ•  ์ˆ˜ ์žˆ์–ด:

[Fact]
public async Task RetryPolicy_Should_Retry_Three_Times()
{
    // Arrange
    var attemptCount = 0;
    var retryPolicy = Policy
        .Handle<InvalidOperationException>()
        .RetryAsync(3);
    
    // Act & Assert
    await Assert.ThrowsAsync<InvalidOperationException>(async () =>
    {
        await retryPolicy.ExecuteAsync(() =>
        {
            attemptCount++;
            throw new InvalidOperationException("Test exception");
        });
    });
    
    Assert.Equal(4, attemptCount); // ์ดˆ๊ธฐ ์‹œ๋„ 1ํšŒ + ์žฌ์‹œ๋„ 3ํšŒ
}

[Fact]
public async Task CircuitBreaker_Should_Open_After_Threshold()
{
    // Arrange
    var circuitBreakerPolicy = Policy
        .Handle<InvalidOperationException>()
        .CircuitBreakerAsync(2, TimeSpan.FromSeconds(10));
    
    // Act - ์ž„๊ณ„๊ฐ’๊นŒ์ง€ ์‹คํŒจ์‹œํ‚ค๊ธฐ
    for (int i = 0; i < 2; i++)
    {
        await Assert.ThrowsAsync<InvalidOperationException>(async () =>
        {
            await circuitBreakerPolicy.ExecuteAsync(() =>
                throw new InvalidOperationException());
        });
    }
    
    // Assert - ํšŒ๋กœ๊ฐ€ ์—ด๋ ธ๋Š”์ง€ ํ™•์ธ
    await Assert.ThrowsAsync<BrokenCircuitException>(async () =>
    {
        await circuitBreakerPolicy.ExecuteAsync(() =>
            Task.CompletedTask);
    });
}

โšก ์„ฑ๋Šฅ ์ตœ์ ํ™”

Polly๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ ์„ฑ๋Šฅ์„ ์ตœ์ ํ™”ํ•˜๋Š” ๋ฐฉ๋ฒ•๋“ค๋„ ์•Œ์•„๋ณด์ž!

1. ์ •์ฑ… ์žฌ์‚ฌ์šฉ

์•ž์„œ ๋งํ–ˆ๋“ฏ์ด, ์ •์ฑ… ๊ฐ์ฒด๋Š” ์žฌ์‚ฌ์šฉํ•ด์•ผ ํ•ด. ๋งค๋ฒˆ ์ƒˆ๋กœ ๋งŒ๋“ค๋ฉด ๋ฉ”๋ชจ๋ฆฌ์™€ CPU๋ฅผ ๋‚ญ๋น„ํ•˜๊ฒŒ ๋ผ!

// โŒ ๋‚˜์œ ์˜ˆ
public async Task<string> BadExample()
{
    var policy = Policy.Handle<Exception>().RetryAsync(3);
    return await policy.ExecuteAsync(() => GetDataAsync());
}

// โœ… ์ข‹์€ ์˜ˆ
private static readonly IAsyncPolicy _policy = 
    Policy.Handle<Exception>().RetryAsync(3);

public async Task<string> GoodExample()
{
    return await _policy.ExecuteAsync(() => GetDataAsync());
}

2. ๋ถˆํ•„์š”ํ•œ ์žฌ์‹œ๋„ ๋ฐฉ์ง€

๋ชจ๋“  ์˜ˆ์™ธ๋ฅผ ์žฌ์‹œ๋„ํ•  ํ•„์š”๋Š” ์—†์–ด. ์žฌ์‹œ๋„ํ•ด๋„ ์†Œ์šฉ์—†๋Š” ์˜ˆ์™ธ๋Š” ์ฆ‰์‹œ ์‹คํŒจ์‹œํ‚ค๋Š” ๊ฒŒ ์ข‹์•„!

var smartRetryPolicy = Policy
    .Handle<HttpRequestException>(ex => 
    {
        // 400๋ฒˆ๋Œ€ ์—๋Ÿฌ๋Š” ์žฌ์‹œ๋„ํ•ด๋„ ์†Œ์šฉ์—†์Œ
        if (ex.StatusCode.HasValue)
        {
            var statusCode = (int)ex.StatusCode.Value;
            return statusCode >= 500; // 500๋ฒˆ๋Œ€๋งŒ ์žฌ์‹œ๋„
        }
        return true;
    })
    .WaitAndRetryAsync(3, retryAttempt => 
        TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

3. ๋น„๋™๊ธฐ ๋ฉ”์„œ๋“œ ์‚ฌ์šฉ

๊ฐ€๋Šฅํ•˜๋ฉด ํ•ญ์ƒ ๋น„๋™๊ธฐ ๋ฒ„์ „์„ ์‚ฌ์šฉํ•ด. ๋™๊ธฐ ๋ฒ„์ „์€ ์Šค๋ ˆ๋“œ๋ฅผ ๋ธ”๋กœํ‚นํ•ด์„œ ์„ฑ๋Šฅ์ด ๋–จ์–ด์ ธ!

// โŒ ๋™๊ธฐ ๋ฒ„์ „ (ํ”ผํ•˜๊ธฐ)
var result = policy.Execute(() => GetData());

// โœ… ๋น„๋™๊ธฐ ๋ฒ„์ „ (๊ถŒ์žฅ)
var result = await policyAsync.ExecuteAsync(async () => 
    await GetDataAsync());

๐ŸŽจ ๊ณ ๊ธ‰ ์‹œ๋‚˜๋ฆฌ์˜ค

์ด์ œ ์ข€ ๋” ๋ณต์žกํ•œ ์‹œ๋‚˜๋ฆฌ์˜ค๋“ค์„ ๋‹ค๋ค„๋ณผ๊ฒŒ!

๋™์  ์ •์ฑ… ์„ ํƒ

์ƒํ™ฉ์— ๋”ฐ๋ผ ๋‹ค๋ฅธ ์ •์ฑ…์„ ์ ์šฉํ•ด์•ผ ํ•  ๋•Œ๊ฐ€ ์žˆ์–ด. ์˜ˆ๋ฅผ ๋“ค์–ด, ์ค‘์š”ํ•œ ์š”์ฒญ๊ณผ ์ผ๋ฐ˜ ์š”์ฒญ์„ ๋‹ค๋ฅด๊ฒŒ ์ฒ˜๋ฆฌํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด:

public class DynamicPolicySelector
{
    private readonly IAsyncPolicy _criticalPolicy;
    private readonly IAsyncPolicy _normalPolicy;
    
    public DynamicPolicySelector()
    {
        // ์ค‘์š”ํ•œ ์š”์ฒญ์šฉ - ๋” ๋งŽ์ด ์žฌ์‹œ๋„
        _criticalPolicy = Policy
            .Handle<HttpRequestException>()
            .WaitAndRetryAsync(5, retryAttempt => 
                TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
        
        // ์ผ๋ฐ˜ ์š”์ฒญ์šฉ - ์ ๊ฒŒ ์žฌ์‹œ๋„
        _normalPolicy = Policy
            .Handle<HttpRequestException>()
            .WaitAndRetryAsync(2, retryAttempt => 
                TimeSpan.FromSeconds(retryAttempt));
    }
    
    public async Task<T> ExecuteAsync<T>(
        Func<Task<T>> action, 
        bool isCritical)
    {
        var policy = isCritical ? _criticalPolicy : _normalPolicy;
        return await policy.ExecuteAsync(action);
    }
}

์กฐ๊ฑด๋ถ€ ์žฌ์‹œ๋„

ํŠน์ • ์กฐ๊ฑด์—์„œ๋งŒ ์žฌ์‹œ๋„ํ•˜๊ณ  ์‹ถ์„ ๋•Œ:

var conditionalRetryPolicy = Policy
    .HandleResult<HttpResponseMessage>(response => 
    {
        // 429 (Too Many Requests)๋‚˜ 503 (Service Unavailable)๋งŒ ์žฌ์‹œ๋„
        return response.StatusCode == HttpStatusCode.TooManyRequests ||
               response.StatusCode == HttpStatusCode.ServiceUnavailable;
    })
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: (retryAttempt, response, context) =>
        {
            // Retry-After ํ—ค๋”๊ฐ€ ์žˆ์œผ๋ฉด ๊ทธ ์‹œ๊ฐ„๋งŒํผ ๋Œ€๊ธฐ
            if (response.Result.Headers.RetryAfter?.Delta.HasValue == true)
            {
                return response.Result.Headers.RetryAfter.Delta.Value;
            }
            
            // ์—†์œผ๋ฉด ์ง€์ˆ˜ ๋ฐฑ์˜คํ”„
            return TimeSpan.FromSeconds(Math.Pow(2, retryAttempt));
        },
        onRetryAsync: async (response, timespan, retryCount, context) =>
        {
            Console.WriteLine(
                $"์žฌ์‹œ๋„ {retryCount}ํšŒ - " +
                $"์ƒํƒœ์ฝ”๋“œ: {response.Result.StatusCode}");
        }
    );

์บ์‹œ์™€ ๊ฒฐํ•ฉํ•˜๊ธฐ

Fallback ํŒจํ„ด๊ณผ ์บ์‹œ๋ฅผ ๊ฒฐํ•ฉํ•˜๋ฉด ๋”์šฑ ๊ฐ•๋ ฅํ•ด์ ธ!

public class CachedApiService
{
    private readonly IMemoryCache _cache;
    private readonly IAsyncPolicy<ApiResponse> _policy;
    
    public CachedApiService(IMemoryCache cache)
    {
        _cache = cache;
        
        _policy = Policy<ApiResponse>
            .Handle<HttpRequestException>()
            .FallbackAsync(
                fallbackAction: async (context, ct) =>
                {
                    var cacheKey = context["CacheKey"] as string;
                    
                    // ์บ์‹œ์—์„œ ๋ฐ์ดํ„ฐ ๊ฐ€์ ธ์˜ค๊ธฐ
                    if (_cache.TryGetValue(cacheKey, out ApiResponse cached))
                    {
                        Console.WriteLine("์บ์‹œ์—์„œ ๋ฐ์ดํ„ฐ ๋ฐ˜ํ™˜");
                        return cached;
                    }
                    
                    // ์บ์‹œ๋„ ์—†์œผ๋ฉด ๊ธฐ๋ณธ๊ฐ’
                    return new ApiResponse 
                    { 
                        Success = false, 
                        Message = "๋ฐ์ดํ„ฐ๋ฅผ ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค" 
                    };
                }
            );
    }
    
    public async Task<ApiResponse> GetDataAsync(string endpoint)
    {
        var cacheKey = $"api_{endpoint}";
        var context = new Context { ["CacheKey"] = cacheKey };
        
        var result = await _policy.ExecuteAsync(async (ctx) =>
        {
            var data = await FetchFromApi(endpoint);
            
            // ์„ฑ๊ณตํ•˜๋ฉด ์บ์‹œ์— ์ €์žฅ
            _cache.Set(cacheKey, data, TimeSpan.FromMinutes(5));
            
            return data;
        }, context);
        
        return result;
    }
}

๐ŸŒ ๋งˆ์ดํฌ๋กœ์„œ๋น„์Šค ํ™˜๊ฒฝ์—์„œ์˜ Polly

๋งˆ์ดํฌ๋กœ์„œ๋น„์Šค ์•„ํ‚คํ…์ฒ˜์—์„œ Polly๋Š” ์ •๋ง ๋น›์„ ๋ฐœํ•ด! ์—ฌ๋Ÿฌ ์„œ๋น„์Šค ๊ฐ„์˜ ํ†ต์‹ ์—์„œ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ๋Š” ๋‹ค์–‘ํ•œ ๋ฌธ์ œ๋“ค์„ ์šฐ์•„ํ•˜๊ฒŒ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ . ๐Ÿ—๏ธ

์„œ๋น„์Šค ๊ฐ„ ํ†ต์‹  ๋ณดํ˜ธ

public class MicroserviceClient
{
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly IAsyncPolicy<HttpResponseMessage> _resiliencePolicy;
    
    public MicroserviceClient(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
        
        // ๋งˆ์ดํฌ๋กœ์„œ๋น„์Šค์šฉ ๋ณตํ•ฉ ์ •์ฑ…
        var timeout = Policy.TimeoutAsync<HttpResponseMessage>(
            TimeSpan.FromSeconds(10));
        
        var retry = Policy
            .HandleResult<HttpResponseMessage>(r => 
                !r.IsSuccessStatusCode && 
                r.StatusCode != HttpStatusCode.BadRequest)
            .WaitAndRetryAsync(3, retryAttempt => 
                TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
        
        var circuitBreaker = Policy
            .HandleResult<HttpResponseMessage>(r => 
                !r.IsSuccessStatusCode)
            .CircuitBreakerAsync(
                handledEventsAllowedBeforeBreaking: 5,
                durationOfBreak: TimeSpan.FromSeconds(30));
        
        var bulkhead = Policy.BulkheadAsync<HttpResponseMessage>(
            maxParallelization: 10,
            maxQueuingActions: 20);
        
        _resiliencePolicy = Policy.WrapAsync(
            bulkhead, circuitBreaker, retry, timeout);
    }
    
    public async Task<ServiceResponse> CallServiceAsync(
        string serviceName, 
        string endpoint)
    {
        var client = _httpClientFactory.CreateClient(serviceName);
        
        var response = await _resiliencePolicy.ExecuteAsync(async () =>
        {
            return await client.GetAsync(endpoint);
        });
        
        if (response.IsSuccessStatusCode)
        {
            var content = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<ServiceResponse>(content);
        }
        
        throw new ServiceCallException(
            $"์„œ๋น„์Šค ํ˜ธ์ถœ ์‹คํŒจ: {serviceName}/{endpoint}");
    }
}
๋งˆ์ดํฌ๋กœ์„œ๋น„์Šค ๋ณต์›๋ ฅ ํŒจํ„ด Service A ์ฃผ๋ฌธ ์„œ๋น„์Šค Service B ๊ฒฐ์ œ ์„œ๋น„์Šค Service C ์žฌ๊ณ  ์„œ๋น„์Šค Service D ์•Œ๋ฆผ ์„œ๋น„์Šค Retry Circuit Breaker Timeout Polly ๋ณต์›๋ ฅ ๊ณ„์ธต ๋ชจ๋“  ์„œ๋น„์Šค ๊ฐ„ ํ†ต์‹ ์„ ๋ณดํ˜ธ Retry ํŒจํ„ด ์ผ์‹œ์  ์žฅ์•  ๋Œ€์‘ ์ž๋™ ์žฌ์‹œ๋„ ์ง€์ˆ˜ ๋ฐฑ์˜คํ”„ ์žฌ์‹œ๋„ ๋กœ๊น… Circuit Breaker ์—ฐ์‡„ ์žฅ์•  ๋ฐฉ์ง€ ํšŒ๋กœ ์ฐจ๋‹จ ์ž๋™ ๋ณต๊ตฌ ์ƒํƒœ ๋ชจ๋‹ˆํ„ฐ๋ง Bulkhead ๋ฆฌ์†Œ์Šค ๊ฒฉ๋ฆฌ ๋™์‹œ์„ฑ ์ œํ•œ ํ ๊ด€๋ฆฌ ๊ณผ๋ถ€ํ•˜ ๋ฐฉ์ง€

๐ŸŽฏ ์‹ค๋ฌด์—์„œ ์ž์ฃผ ํ•˜๋Š” ์‹ค์ˆ˜๋“ค

Polly๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด์„œ ๊ฐœ๋ฐœ์ž๋“ค์ด ์ž์ฃผ ํ•˜๋Š” ์‹ค์ˆ˜๋“ค์„ ์ •๋ฆฌํ•ด๋ดค์–ด. ์ด๊ฑธ ํ”ผํ•˜๋ฉด ํ›จ์”ฌ ์•ˆ์ •์ ์ธ ์‹œ์Šคํ…œ์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด! ๐Ÿšซ

์‹ค์ˆ˜ 1: ๋ชจ๋“  ์˜ˆ์™ธ๋ฅผ ์žฌ์‹œ๋„ํ•˜๊ธฐ

// โŒ ๋‚˜์œ ์˜ˆ - ๋ชจ๋“  ์˜ˆ์™ธ๋ฅผ ์žฌ์‹œ๋„
var badPolicy = Policy
    .Handle<Exception>()  // ๋ชจ๋“  ์˜ˆ์™ธ!
    .Retry(3);

// โœ… ์ข‹์€ ์˜ˆ - ํŠน์ • ์˜ˆ์™ธ๋งŒ ์žฌ์‹œ๋„
var goodPolicy = Policy
    .Handle<HttpRequestException>()
    .Or<TimeoutException>()
    .Or<TaskCanceledException>()
    .Retry(3);
โš ๏ธ ์™œ ๋ฌธ์ œ์ผ๊นŒ? ArgumentNullException์ด๋‚˜ InvalidOperationException ๊ฐ™์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์˜ค๋ฅ˜๋Š” ์žฌ์‹œ๋„ํ•ด๋„ ์ ˆ๋Œ€ ์„ฑ๊ณตํ•˜์ง€ ์•Š์•„. ์˜คํžˆ๋ ค ๋กœ๊ทธ๋งŒ ๊ฐ€๋“ ์ฐจ๊ณ  ๋””๋ฒ„๊น…์ด ์–ด๋ ค์›Œ์ ธ. ์žฌ์‹œ๋„๋Š” ์ผ์‹œ์ ์ธ ์žฅ์• (Transient Fault)์—๋งŒ ์ ์šฉํ•ด์•ผ ํ•ด!

์‹ค์ˆ˜ 2: ์žฌ์‹œ๋„ ํšŸ์ˆ˜๊ฐ€ ๋„ˆ๋ฌด ๋งŽ์Œ

// โŒ ๋‚˜์œ ์˜ˆ - ๊ณผ๋„ํ•œ ์žฌ์‹œ๋„
var badPolicy = Policy
    .Handle<HttpRequestException>()
    .Retry(100);  // 100๋ฒˆ์ด๋‚˜!

// โœ… ์ข‹์€ ์˜ˆ - ์ ์ ˆํ•œ ์žฌ์‹œ๋„
var goodPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(3, retryAttempt => 
        TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

์‹ค์ˆ˜ 3: Circuit Breaker ์—†์ด Retry๋งŒ ์‚ฌ์šฉ

์„œ๋น„์Šค๊ฐ€ ์™„์ „ํžˆ ๋‹ค์šด๋˜์—ˆ์„ ๋•Œ ๊ณ„์† ์žฌ์‹œ๋„๋งŒ ํ•˜๋ฉด ๋ฆฌ์†Œ์Šค๋งŒ ๋‚ญ๋น„๋ผ. ๋ฐ˜๋“œ์‹œ Circuit Breaker์™€ ํ•จ๊ป˜ ์‚ฌ์šฉํ•ด์•ผ ํ•ด!

// โœ… Retry + Circuit Breaker ์กฐํ•ฉ
var combinedPolicy = Policy.Wrap(
    Policy.Handle<HttpRequestException>()
        .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1)),
    Policy.Handle<HttpRequestException>()
        .WaitAndRetryAsync(3, retryAttempt => 
            TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)))
);

์‹ค์ˆ˜ 4: ํƒ€์ž„์•„์›ƒ์ด ์žฌ์‹œ๋„ ๊ฐ„๊ฒฉ๋ณด๋‹ค ์งง์Œ

// โŒ ๋‚˜์œ ์˜ˆ - ํƒ€์ž„์•„์›ƒ์ด ๋„ˆ๋ฌด ์งง์Œ
var timeout = Policy.TimeoutAsync(TimeSpan.FromSeconds(1));
var retry = Policy
    .Handle<TimeoutRejectedException>()
    .WaitAndRetryAsync(3, retryAttempt => 
        TimeSpan.FromSeconds(5));  // 5์ดˆ ๋Œ€๊ธฐํ•˜๋Š”๋ฐ ํƒ€์ž„์•„์›ƒ์€ 1์ดˆ?

// โœ… ์ข‹์€ ์˜ˆ - ์ ์ ˆํ•œ ํƒ€์ž„์•„์›ƒ
var timeout = Policy.TimeoutAsync(TimeSpan.FromSeconds(30));
var retry = Policy
    .Handle<TimeoutRejectedException>()
    .WaitAndRetryAsync(3, retryAttempt => 
        TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

๐Ÿ“š ์ถ”๊ฐ€ ํ•™์Šต ์ž๋ฃŒ์™€ ์ปค๋ฎค๋‹ˆํ‹ฐ

Polly์— ๋Œ€ํ•ด ๋” ๊นŠ์ด ๊ณต๋ถ€ํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด ์ด๋Ÿฐ ์ž๋ฃŒ๋“ค์„ ์ฐธ๊ณ ํ•ด๋ด! ๐Ÿ“–

๐Ÿ”— ์œ ์šฉํ•œ ๋ฆฌ์†Œ์Šค ๊ณต์‹ GitHub: https://github.com/App-vNext/Polly
๊ณต์‹ ๋ฌธ์„œ: https://www.pollydocs.org/
Wiki: Polly GitHub Wiki์— ๋‹ค์–‘ํ•œ ์˜ˆ์ œ์™€ ํŒจํ„ด์ด ์žˆ์–ด
NuGet: ์ตœ์‹  ๋ฒ„์ „๊ณผ ๋‹ค์šด๋กœ๋“œ ํ†ต๊ณ„ ํ™•์ธ ๊ฐ€๋Šฅ
Stack Overflow: 'polly' ํƒœ๊ทธ๋กœ ์งˆ๋ฌธ๊ณผ ๋‹ต๋ณ€ ๊ฒ€์ƒ‰

๐ŸŽฌ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€! ์—ฌ๊ธฐ๊นŒ์ง€ ์ •๋ง ๊ธด ์—ฌ์ •์ด์—ˆ์–ด. Polly์˜ ๊ธฐ๋ณธ ๊ฐœ๋…๋ถ€ํ„ฐ ๊ณ ๊ธ‰ ํŒจํ„ด, ์‹ค์ „ ํ™œ์šฉ๋ฒ•๊นŒ์ง€ ๋ชจ๋‘ ๋‹ค๋ค„๋ดค์–ด. ๐ŸŽ‰

ํ•ต์‹ฌ์„ ์ •๋ฆฌํ•˜์ž๋ฉด:

โœจ Polly ํ•ต์‹ฌ ์š”์•ฝ 1๏ธโƒฃ Retry: ์ผ์‹œ์  ์žฅ์• ์— ๋Œ€์‘ํ•˜๋Š” ๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ํŒจํ„ด

2๏ธโƒฃ Circuit Breaker: ์—ฐ์‡„ ์žฅ์• ๋ฅผ ๋ฐฉ์ง€ํ•˜๋Š” ํ•„์ˆ˜ ํŒจํ„ด

3๏ธโƒฃ Timeout: ๋ฌดํ•œ ๋Œ€๊ธฐ๋ฅผ ๋ฐฉ์ง€ํ•˜๋Š” ์•ˆ์ „์žฅ์น˜

4๏ธโƒฃ Fallback: ์šฐ์•„ํ•œ ์‹คํŒจ ์ฒ˜๋ฆฌ๋กœ ์‚ฌ์šฉ์ž ๊ฒฝํ—˜ ๊ฐœ์„ 

5๏ธโƒฃ Bulkhead: ๋ฆฌ์†Œ์Šค ๊ฒฉ๋ฆฌ๋กœ ์‹œ์Šคํ…œ ์ „์ฒด ๋งˆ๋น„ ๋ฐฉ์ง€

6๏ธโƒฃ Policy Wrap: ์—ฌ๋Ÿฌ ํŒจํ„ด์„ ์กฐํ•ฉํ•ด์„œ ๊ฐ•๋ ฅํ•œ ๋ณต์›๋ ฅ ๊ตฌํ˜„

์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ์•ˆ์ •์ ์ธ ์„œ๋น„์Šค๋ฅผ ์ œ๊ณตํ•˜๋ ค๋ฉด ์ด๋Ÿฐ ๋ณต์›๋ ฅ ํŒจํ„ด๋“ค์ด ์ •๋ง ์ค‘์š”ํ•ด. ์‚ฌ์šฉ์ž๋“ค์€ ํ•ญ์ƒ ๋น ๋ฅด๊ณ  ์•ˆ์ •์ ์ธ ์„œ๋น„์Šค๋ฅผ ๊ธฐ๋Œ€ํ•˜๋‹ˆ๊นŒ! ๐Ÿ’ช

์ฒ˜์Œ์—๋Š” ๋ณต์žกํ•ด ๋ณด์ผ ์ˆ˜ ์žˆ์ง€๋งŒ, ํ•˜๋‚˜์”ฉ ์ ์šฉํ•ด๋ณด๋ฉด์„œ ์ต์ˆ™ํ•ด์ง€๋ฉด ๋ผ. ์ž‘์€ ํ”„๋กœ์ ํŠธ์—์„œ ์‹œ์ž‘ํ•ด์„œ ์ ์ฐจ ๋ณต์žกํ•œ ์‹œ๋‚˜๋ฆฌ์˜ค๋กœ ํ™•์žฅํ•ด๋‚˜๊ฐ€๋Š” ๊ฑธ ์ถ”์ฒœํ•ด! ๐Ÿš€

๊ทธ๋ฆฌ๊ณ  ๊ธฐ์–ตํ•ด! ์™„๋ฒฝํ•œ ์‹œ์Šคํ…œ์€ ์—†์–ด. ์ค‘์š”ํ•œ ๊ฑด ์žฅ์• ๊ฐ€ ๋ฐœ์ƒํ–ˆ์„ ๋•Œ ์–ด๋–ป๊ฒŒ ๋Œ€์‘ํ•˜๋А๋ƒ์•ผ. Polly๋Š” ๋ฐ”๋กœ ๊ทธ ๋Œ€์‘ ์ „๋žต์„ ์šฐ์•„ํ•˜๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋„์™€์ฃผ๋Š” ๋„๊ตฌ์ง€. ๐Ÿ›ก๏ธ

ํ˜น์‹œ Polly๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด์„œ ๊ถ๊ธˆํ•œ ์ ์ด ์ƒ๊ธฐ๊ฑฐ๋‚˜, ํŠน์ • ์‹œ๋‚˜๋ฆฌ์˜ค์— ๋Œ€ํ•œ ์กฐ์–ธ์ด ํ•„์š”ํ•˜๋ฉด ์–ธ์ œ๋“  ์ปค๋ฎค๋‹ˆํ‹ฐ์— ๋ฌผ์–ด๋ด. ๋งŽ์€ ๊ฐœ๋ฐœ์ž๋“ค์ด ๊ธฐ๊บผ์ด ๋„์™€์ค„ ๊ฑฐ์•ผ! ๐Ÿ˜Š

์ž, ์ด์ œ ๋‹น์‹ ์˜ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์— Polly๋ฅผ ์ ์šฉํ•ด์„œ ๋”์šฑ ๊ฒฌ๊ณ ํ•˜๊ณ  ์•ˆ์ •์ ์ธ ์‹œ์Šคํ…œ์„ ๋งŒ๋“ค์–ด๋ด! ํ™”์ดํŒ…! ๐ŸŽฏโœจ

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.