Ver3.0 ๐ก๏ธ Polly๋ก ๊ตฌํํ๋ ๋ณต์๋ ฅ ํจํด๊ณผ ์ฅ์ ๋์ ์ ๋ต ์๋ฒฝ ๊ฐ์ด๋

๐ก๏ธ Polly๋ก ๊ตฌํํ๋ ๋ณต์๋ ฅ ํจํด๊ณผ ์ฅ์ ๋์ ์ ๋ต ์๋ฒฝ ๊ฐ์ด๋
C# ๊ฐ๋ฐ์๋ฅผ ์ํ ์ค์ ์ฅ์ ์ฒ๋ฆฌ ๊ธฐ๋ฒ ๐ช
์๋
! ์ค๋์ C# ๊ฐ๋ฐ์๋ผ๋ฉด ๊ผญ ์์์ผ ํ Polly ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ํด ์ด์ผ๊ธฐํด๋ณผ๊ฒ. ํน์ ๋คํธ์ํฌ ์์ฒญ์ด ์คํจํ์ ๋, ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๊ฒฐ์ด ๋๊ฒผ์ ๋, ์ธ๋ถ API๊ฐ ์๋ตํ์ง ์์ ๋ ์ด๋ป๊ฒ ๋์ํ๊ณ ์์ด? ๐ค
"์๋ฌ ๋๋ฉด ๊ทธ๋ฅ try-catch๋ก ์ก์ผ๋ฉด ๋๋ ๊ฑฐ ์๋์ผ?"๋ผ๊ณ ์๊ฐํ ์๋ ์์ง. ํ์ง๋ง ์ค์ ํ๋ก๋์
ํ๊ฒฝ์์๋ ํจ์ฌ ๋ ์ ๊ตํ ์ฅ์ ๋์ ์ ๋ต์ด ํ์ํด. ๋ฐ๋ก ์ฌ๊ธฐ์ Polly๊ฐ ๋น์ ๋ฐํ๋ ๊ฑฐ์ผ! โจ
๐ฏ Polly๊ฐ ๋ญ๊ธธ๋?
Polly๋ .NET์ฉ ๋ณต์๋ ฅ(Resilience)๊ณผ ์ผ์์ ์ฅ์ ์ฒ๋ฆฌ(Transient Fault Handling) ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ผ. ๊ฐ๋จํ ๋งํ๋ฉด, ์ ํ๋ฆฌ์ผ์ด์
์ด ์์์น ๋ชปํ ์ค๋ฅ๋ ์ฅ์ ์ํฉ์์๋ ์ฐ์ํ๊ฒ ๋์ํ ์ ์๋๋ก ๋์์ฃผ๋ ๋๊ตฌ๋ผ๊ณ ์๊ฐํ๋ฉด ๋ผ.
๋ง์ดํฌ๋ก์ํํธ๋ ๊ณต์์ ์ผ๋ก ์ถ์ฒํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ด๊ณ , .NET Core์ .NET Framework ๋ชจ๋์์ ์ฌ์ฉํ ์ ์์ด. NuGet ํจํค์ง๋ก ์ฝ๊ฒ ์ค์นํ ์ ์๊ณ , ์ฌ์ฉ๋ฒ๋ ์ง๊ด์ ์ด๋ผ ๊ธ๋ฐฉ ์ตํ ์ ์์ด! ๐
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}์ด ๋๊ธฐ");
}
);
์ ์ด๋ ๊ฒ ํ ๊น? ์๋ฒ๊ฐ ๊ณผ๋ถํ ์ํ์ผ ๋ ์ฆ์ ์ฌ์๋ํ๋ฉด ์ํฉ์ ๋ ์ ํ์ํฌ ์ ์๊ฑฐ๋ . ์๊ฐ์ ๋๊ณ ์ฌ์๋ํ๋ฉด ์๋ฒ๊ฐ ํ๋ณตํ ์๊ฐ์ ์ฃผ๋ ๊ฑฐ์ง! ๐
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("ํ๋ก ๋ฐ๊ฐ๋ฐฉ - ํ
์คํธ ์์ฒญ ์๋");
}
);
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;
});
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);
โข ํ์ ์์ ์ฑ: ์ ๋ค๋ฆญ ํ์ ์ฒ๋ฆฌ๊ฐ ๊ฐ์ ๋์ด ์ปดํ์ผ ํ์์ ๋ ๋ง์ ์ค๋ฅ๋ฅผ ์ก์ ์ ์์ด
โข ํ ๋ ๋ฉํธ๋ฆฌ: 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 ์๊ณ๊ฐ ์ค์
์ํท ๋ธ๋ ์ด์ปค์ ์๊ณ๊ฐ์ ํธ๋ํฝ ํจํด์ ๋ฐ๋ผ ๋ฌ๋ผ์ ธ์ผ ํด. ์ผ๋ฐ์ ์ธ ๊ฐ์ด๋๋ผ์ธ์:
์ต์ ์ฒ๋ฆฌ๋: ์ต์ 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}");
}
}
๐ฏ ์ค๋ฌด์์ ์์ฃผ ํ๋ ์ค์๋ค
Polly๋ฅผ ์ฌ์ฉํ๋ฉด์ ๊ฐ๋ฐ์๋ค์ด ์์ฃผ ํ๋ ์ค์๋ค์ ์ ๋ฆฌํด๋ดค์ด. ์ด๊ฑธ ํผํ๋ฉด ํจ์ฌ ์์ ์ ์ธ ์์คํ ์ ๋ง๋ค ์ ์์ด! ๐ซ
์ค์ 1: ๋ชจ๋ ์์ธ๋ฅผ ์ฌ์๋ํ๊ธฐ
// โ ๋์ ์ - ๋ชจ๋ ์์ธ๋ฅผ ์ฌ์๋
var badPolicy = Policy
.Handle<Exception>() // ๋ชจ๋ ์์ธ!
.Retry(3);
// โ
์ข์ ์ - ํน์ ์์ธ๋ง ์ฌ์๋
var goodPolicy = Policy
.Handle<HttpRequestException>()
.Or<TimeoutException>()
.Or<TaskCanceledException>()
.Retry(3);
์ค์ 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์ ๋ํด ๋ ๊น์ด ๊ณต๋ถํ๊ณ ์ถ๋ค๋ฉด ์ด๋ฐ ์๋ฃ๋ค์ ์ฐธ๊ณ ํด๋ด! ๐
๊ณต์ ๋ฌธ์: https://www.pollydocs.org/
Wiki: Polly GitHub Wiki์ ๋ค์ํ ์์ ์ ํจํด์ด ์์ด
NuGet: ์ต์ ๋ฒ์ ๊ณผ ๋ค์ด๋ก๋ ํต๊ณ ํ์ธ ๊ฐ๋ฅ
Stack Overflow: 'polly' ํ๊ทธ๋ก ์ง๋ฌธ๊ณผ ๋ต๋ณ ๊ฒ์
๐ฌ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์! ์ฌ๊ธฐ๊น์ง ์ ๋ง ๊ธด ์ฌ์ ์ด์์ด. Polly์ ๊ธฐ๋ณธ ๊ฐ๋
๋ถํฐ ๊ณ ๊ธ ํจํด, ์ค์ ํ์ฉ๋ฒ๊น์ง ๋ชจ๋ ๋ค๋ค๋ดค์ด. ๐
ํต์ฌ์ ์ ๋ฆฌํ์๋ฉด:
2๏ธโฃ Circuit Breaker: ์ฐ์ ์ฅ์ ๋ฅผ ๋ฐฉ์งํ๋ ํ์ ํจํด
3๏ธโฃ Timeout: ๋ฌดํ ๋๊ธฐ๋ฅผ ๋ฐฉ์งํ๋ ์์ ์ฅ์น
4๏ธโฃ Fallback: ์ฐ์ํ ์คํจ ์ฒ๋ฆฌ๋ก ์ฌ์ฉ์ ๊ฒฝํ ๊ฐ์
5๏ธโฃ Bulkhead: ๋ฆฌ์์ค ๊ฒฉ๋ฆฌ๋ก ์์คํ ์ ์ฒด ๋ง๋น ๋ฐฉ์ง
6๏ธโฃ Policy Wrap: ์ฌ๋ฌ ํจํด์ ์กฐํฉํด์ ๊ฐ๋ ฅํ ๋ณต์๋ ฅ ๊ตฌํ
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ์์ ์ ์ธ ์๋น์ค๋ฅผ ์ ๊ณตํ๋ ค๋ฉด ์ด๋ฐ ๋ณต์๋ ฅ ํจํด๋ค์ด ์ ๋ง ์ค์ํด. ์ฌ์ฉ์๋ค์ ํญ์ ๋น ๋ฅด๊ณ ์์ ์ ์ธ ์๋น์ค๋ฅผ ๊ธฐ๋ํ๋๊น! ๐ช
์ฒ์์๋ ๋ณต์กํด ๋ณด์ผ ์ ์์ง๋ง, ํ๋์ฉ ์ ์ฉํด๋ณด๋ฉด์ ์ต์ํด์ง๋ฉด ๋ผ. ์์ ํ๋ก์ ํธ์์ ์์ํด์ ์ ์ฐจ ๋ณต์กํ ์๋๋ฆฌ์ค๋ก ํ์ฅํด๋๊ฐ๋ ๊ฑธ ์ถ์ฒํด! ๐
๊ทธ๋ฆฌ๊ณ ๊ธฐ์ตํด! ์๋ฒฝํ ์์คํ
์ ์์ด. ์ค์ํ ๊ฑด ์ฅ์ ๊ฐ ๋ฐ์ํ์ ๋ ์ด๋ป๊ฒ ๋์ํ๋๋์ผ. Polly๋ ๋ฐ๋ก ๊ทธ ๋์ ์ ๋ต์ ์ฐ์ํ๊ฒ ๊ตฌํํ ์ ์๊ฒ ๋์์ฃผ๋ ๋๊ตฌ์ง. ๐ก๏ธ
ํน์ Polly๋ฅผ ์ฌ์ฉํ๋ฉด์ ๊ถ๊ธํ ์ ์ด ์๊ธฐ๊ฑฐ๋, ํน์ ์๋๋ฆฌ์ค์ ๋ํ ์กฐ์ธ์ด ํ์ํ๋ฉด ์ธ์ ๋ ์ปค๋ฎค๋ํฐ์ ๋ฌผ์ด๋ด. ๋ง์ ๊ฐ๋ฐ์๋ค์ด ๊ธฐ๊บผ์ด ๋์์ค ๊ฑฐ์ผ! ๐
์, ์ด์ ๋น์ ์ ์ ํ๋ฆฌ์ผ์ด์
์ Polly๋ฅผ ์ ์ฉํด์ ๋์ฑ ๊ฒฌ๊ณ ํ๊ณ ์์ ์ ์ธ ์์คํ
์ ๋ง๋ค์ด๋ด! ํ์ดํ
! ๐ฏโจ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.