🏛️ WCF: 마이크로소프트의 통신 프레임워크

WCF는 2006년에 마이크로소프트가 .NET Framework 3.0과 함께 출시한 통신 프레임워크야. 당시에는 정말 혁신적이었어! 🎉

WCF 이전에는 웹 서비스를 만들려면 ASMX, Remoting, MSMQ 등 여러 기술을 따로따로 배워야 했거든. 근데 WCF는 이 모든 걸 하나로 통합했어. 마치 스위스 아미 나이프처럼 하나로 여러 기능을 제공하는 거지! 🔧

WCF를 이해하려면 ABC를 알아야 해. 이건 Address, Binding, Contract의 약자야.

📍 Address (주소): 서비스가 어디에 있는지 알려주는 위치 정보야. 마치 집 주소처럼!
예를 들면 http://localhost:8080/MyService 이런 식이지.

🔗 Binding (바인딩): 어떤 방식으로 통신할 건지 정하는 거야. HTTP를 쓸 건지, TCP를 쓸 건지, 보안은 어떻게 할 건지 등등.

📋 Contract (계약): 서비스가 어떤 기능을 제공하는지 정의하는 인터페이스야. 메뉴판 같은 거라고 생각하면 돼!

실전 WCF 서비스 구현하기

자, 이제 실제로 WCF 서비스를 만들어볼까? 간단한 계산기 서비스를 만들어보자! 🧮

먼저 서비스 계약(Service Contract)을 정의해야 해:

using System.ServiceModel;

[ServiceContract]
public interface ICalculatorService
{
    [OperationContract]
    int Add(int a, int b);
    
    [OperationContract]
    int Subtract(int a, int b);
    
    [OperationContract]
    int Multiply(int a, int b);
    
    [OperationContract]
    double Divide(int a, int b);
}

[ServiceContract] 어트리뷰트는 "이 인터페이스는 WCF 서비스야!"라고 선언하는 거고, [OperationContract]는 "이 메서드는 외부에서 호출할 수 있어!"라고 알려주는 거야.

이제 실제 구현 클래스를 만들어보자:

public class CalculatorService : ICalculatorService
{
    public int Add(int a, int b)
    {
        Console.WriteLine($"Add 호출됨: {a} + {b}");
        return a + b;
    }
    
    public int Subtract(int a, int b)
    {
        Console.WriteLine($"Subtract 호출됨: {a} - {b}");
        return a - b;
    }
    
    public int Multiply(int a, int b)
    {
        Console.WriteLine($"Multiply 호출됨: {a} * {b}");
        return a * b;
    }
    
    public double Divide(int a, int b)
    {
        if (b == 0)
            throw new DivideByZeroException("0으로 나눌 수 없습니다!");
        
        Console.WriteLine($"Divide 호출됨: {a} / {b}");
        return (double)a / b;
    }
}

서비스를 호스팅하는 코드도 필요해. 콘솔 애플리케이션으로 간단하게 만들어볼게:

using System;
using System.ServiceModel;

class Program
{
    static void Main(string[] args)
    {
        // 서비스 호스트 생성
        using (ServiceHost host = new ServiceHost(typeof(CalculatorService)))
        {
            // 엔드포인트 추가 (Address, Binding, Contract)
            host.AddServiceEndpoint(
                typeof(ICalculatorService),
                new BasicHttpBinding(),
                "http://localhost:8080/Calculator"
            );
            
            // 메타데이터 교환 활성화 (클라이언트가 서비스 정보를 가져갈 수 있게)
            ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
            smb.HttpGetEnabled = true;
            host.Description.Behaviors.Add(smb);
            
            // 서비스 시작
            host.Open();
            Console.WriteLine("계산기 서비스가 시작되었습니다!");
            Console.WriteLine("주소: http://localhost:8080/Calculator");
            Console.WriteLine("종료하려면 Enter를 누르세요...");
            Console.ReadLine();
            
            // 서비스 종료
            host.Close();
        }
    }
}

클라이언트 코드는 이렇게 만들 수 있어:

using System;
using System.ServiceModel;

class Client
{
    static void Main(string[] args)
    {
        // 채널 팩토리 생성
        ChannelFactory<ICalculatorService> factory = 
            new ChannelFactory<ICalculatorService>(
                new BasicHttpBinding(),
                new EndpointAddress("http://localhost:8080/Calculator")
            );
        
        // 프록시 생성
        ICalculatorService proxy = factory.CreateChannel();
        
        try
        {
            // 서비스 호출
            Console.WriteLine($"10 + 5 = {proxy.Add(10, 5)}");
            Console.WriteLine($"10 - 5 = {proxy.Subtract(10, 5)}");
            Console.WriteLine($"10 * 5 = {proxy.Multiply(10, 5)}");
            Console.WriteLine($"10 / 5 = {proxy.Divide(10, 5)}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"오류 발생: {ex.Message}");
        }
        finally
        {
            // 채널 닫기
            ((IClientChannel)proxy).Close();
            factory.Close();
        }
        
        Console.ReadLine();
    }
}

WCF의 고급 기능들

WCF는 기본적인 통신 외에도 엄청나게 많은 기능을 제공해. 몇 가지 중요한 것들을 살펴보자! 🎓

복잡한 객체를 주고받을 때는 데이터 계약을 사용해야 해:

using System.Runtime.Serialization;

[DataContract]
public class Customer
{
    [DataMember]
    public int Id { get; set; }
    
    [DataMember]
    public string Name { get; set; }
    
    [DataMember]
    public string Email { get; set; }
    
    // 이 속성은 직렬화되지 않음 (DataMember 없음)
    public string InternalNote { get; set; }
}

[ServiceContract]
public interface ICustomerService
{
    [OperationContract]
    Customer GetCustomer(int id);
    
    [OperationContract]
    void SaveCustomer(Customer customer);
}

서비스에서 발생한 오류를 클라이언트에게 제대로 전달하려면 Fault Contract를 사용해:

[DataContract]
public class CustomerFault
{
    [DataMember]
    public string ErrorMessage { get; set; }
    
    [DataMember]
    public string ErrorCode { get; set; }
}

[ServiceContract]
public interface ICustomerService
{
    [OperationContract]
    [FaultContract(typeof(CustomerFault))]
    Customer GetCustomer(int id);
}

public class CustomerService : ICustomerService
{
    public Customer GetCustomer(int id)
    {
        if (id <= 0)
        {
            CustomerFault fault = new CustomerFault
            {
                ErrorMessage = "잘못된 고객 ID입니다.",
                ErrorCode = "INVALID_ID"
            };
            throw new FaultException<CustomerFault>(fault);
        }
        
        // 정상 처리...
        return new Customer { Id = id, Name = "홍길동" };
    }
}

WCF는 상태를 유지하는 세션 기반 서비스도 만들 수 있어:

[ServiceContract(SessionMode = SessionMode.Required)]
public interface IShoppingCartService
{
    [OperationContract]
    void AddItem(string itemName, int quantity);
    
    [OperationContract]
    void RemoveItem(string itemName);
    
    [OperationContract]
    List<string> GetCartItems();
    
    [OperationContract]
    void Checkout();
}

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
public class ShoppingCartService : IShoppingCartService
{
    private Dictionary<string, int> cart = new Dictionary<string, int>();
    
    public void AddItem(string itemName, int quantity)
    {
        if (cart.ContainsKey(itemName))
            cart[itemName] += quantity;
        else
            cart[itemName] = quantity;
            
        Console.WriteLine($"{itemName} {quantity}개 추가됨");
    }
    
    public void RemoveItem(string itemName)
    {
        if (cart.ContainsKey(itemName))
        {
            cart.Remove(itemName);
            Console.WriteLine($"{itemName} 제거됨");
        }
    }
    
    public List<string> GetCartItems()
    {
        List<string> items = new List<string>();
        foreach (var item in cart)
        {
            items.Add($"{item.Key}: {item.Value}개");
        }
        return items;
    }
    
    public void Checkout()
    {
        Console.WriteLine("결제 처리 중...");
        cart.Clear();
    }
}

⚡ gRPC: 구글의 차세대 RPC 프레임워크

자, 이제 gRPC 이야기를 해볼까? gRPC는 구글이 만든 현대적인 RPC(Remote Procedure Call) 프레임워크야. 🚀

2015년에 오픈소스로 공개됐는데, 요즘 마이크로서비스 아키텍처에서 엄청나게 인기가 많아. 왜 그럴까? 성능이 미친 듯이 빠르거든! ⚡

gRPC의 가장 큰 특징은 HTTP/2를 기반으로 한다는 거야. HTTP/1.1과 비교하면 엄청난 성능 향상이 있지. 그리고 Protocol Buffers(줄여서 Protobuf)라는 직렬화 포맷을 사용해서 데이터를 주고받아.

Protocol Buffers 이해하기

gRPC를 사용하려면 먼저 Protocol Buffers를 이해해야 해. Protobuf는 구조화된 데이터를 직렬화하는 방법이야. 📦

JSON이나 XML처럼 데이터를 표현하는 방법인데, 훨씬 효율적이지. .proto 파일에 데이터 구조를 정의하면, 컴파일러가 자동으로 C# 코드를 생성해줘.

// calculator.proto
syntax = "proto3";

option csharp_namespace = "CalculatorService";

package calculator;

// 계산기 서비스 정의
service Calculator {
  rpc Add (CalculateRequest) returns (CalculateResponse);
  rpc Subtract (CalculateRequest) returns (CalculateResponse);
  rpc Multiply (CalculateRequest) returns (CalculateResponse);
  rpc Divide (CalculateRequest) returns (CalculateResponse);
}

// 요청 메시지
message CalculateRequest {
  int32 a = 1;
  int32 b = 2;
}

// 응답 메시지
message CalculateResponse {
  double result = 1;
  string message = 2;
}

보면 알겠지만 문법이 엄청 간단해! 😊

syntax = "proto3"는 Protocol Buffers 버전 3을 사용한다는 뜻이고,
service 블록에서 RPC 메서드들을 정의하고,
message 블록에서 데이터 구조를 정의해.

각 필드 옆의 숫자(1, 2 등)는 필드 번호야. 이게 실제 바이너리 인코딩에서 사용되는 식별자거든.

gRPC 서버 구현하기

이제 실제로 gRPC 서버를 만들어보자! 먼저 NuGet 패키지를 설치해야 해:

dotnet add package Grpc.AspNetCore
dotnet add package Google.Protobuf
dotnet add package Grpc.Tools

위에서 만든 calculator.proto 파일을 프로젝트에 추가하고, .csproj 파일에 이렇게 설정해:

<ItemGroup>
  <Protobuf Include="Protos\calculator.proto" GrpcServices="Server" />
</ItemGroup>

빌드하면 자동으로 C# 코드가 생성돼. 이제 서비스를 구현하자:

using Grpc.Core;
using CalculatorService;

public class CalculatorServiceImpl : Calculator.CalculatorBase
{
    private readonly ILogger<CalculatorServiceImpl> _logger;
    
    public CalculatorServiceImpl(ILogger<CalculatorServiceImpl> logger)
    {
        _logger = logger;
    }
    
    public override Task<CalculateResponse> Add(
        CalculateRequest request, 
        ServerCallContext context)
    {
        _logger.LogInformation($"Add 호출: {request.A} + {request.B}");
        
        var response = new CalculateResponse
        {
            Result = request.A + request.B,
            Message = "덧셈 완료"
        };
        
        return Task.FromResult(response);
    }
    
    public override Task<CalculateResponse> Subtract(
        CalculateRequest request, 
        ServerCallContext context)
    {
        _logger.LogInformation($"Subtract 호출: {request.A} - {request.B}");
        
        var response = new CalculateResponse
        {
            Result = request.A - request.B,
            Message = "뺄셈 완료"
        };
        
        return Task.FromResult(response);
    }
    
    public override Task<CalculateResponse> Multiply(
        CalculateRequest request, 
        ServerCallContext context)
    {
        _logger.LogInformation($"Multiply 호출: {request.A} * {request.B}");
        
        var response = new CalculateResponse
        {
            Result = request.A * request.B,
            Message = "곱셈 완료"
        };
        
        return Task.FromResult(response);
    }
    
    public override Task<CalculateResponse> Divide(
        CalculateRequest request, 
        ServerCallContext context)
    {
        if (request.B == 0)
        {
            throw new RpcException(
                new Status(StatusCode.InvalidArgument, "0으로 나눌 수 없습니다!")
            );
        }
        
        _logger.LogInformation($"Divide 호출: {request.A} / {request.B}");
        
        var response = new CalculateResponse
        {
            Result = (double)request.A / request.B,
            Message = "나눗셈 완료"
        };
        
        return Task.FromResult(response);
    }
}

ASP.NET Core에서 gRPC 서비스를 호스팅하려면 Program.cs를 이렇게 설정해:

var builder = WebApplication.CreateBuilder(args);

// gRPC 서비스 추가
builder.Services.AddGrpc();

var app = builder.Build();

// gRPC 엔드포인트 매핑
app.MapGrpcService<CalculatorServiceImpl>();

app.MapGet("/", () => 
    "gRPC 서비스가 실행 중입니다. gRPC 클라이언트로 연결하세요.");

app.Run();

gRPC 클라이언트 구현하기

클라이언트도 만들어보자! 먼저 필요한 패키지를 설치:

dotnet add package Grpc.Net.Client
dotnet add package Google.Protobuf
dotnet add package Grpc.Tools

클라이언트 프로젝트에도 같은 .proto 파일을 추가하되, GrpcServices="Client"로 설정해:

<ItemGroup>
  <Protobuf Include="Protos\calculator.proto" GrpcServices="Client" />
</ItemGroup>

이제 클라이언트 코드를 작성하자:

using Grpc.Net.Client;
using CalculatorService;

class Program
{
    static async Task Main(string[] args)
    {
        // gRPC 채널 생성
        using var channel = GrpcChannel.ForAddress("https://localhost:5001");
        var client = new Calculator.CalculatorClient(channel);
        
        try
        {
            // 덧셈 호출
            var addRequest = new CalculateRequest { A = 10, B = 5 };
            var addResponse = await client.AddAsync(addRequest);
            Console.WriteLine($"10 + 5 = {addResponse.Result}");
            Console.WriteLine($"메시지: {addResponse.Message}");
            
            // 뺄셈 호출
            var subtractRequest = new CalculateRequest { A = 10, B = 5 };
            var subtractResponse = await client.SubtractAsync(subtractRequest);
            Console.WriteLine($"10 - 5 = {subtractResponse.Result}");
            
            // 곱셈 호출
            var multiplyRequest = new CalculateRequest { A = 10, B = 5 };
            var multiplyResponse = await client.MultiplyAsync(multiplyRequest);
            Console.WriteLine($"10 * 5 = {multiplyResponse.Result}");
            
            // 나눗셈 호출
            var divideRequest = new CalculateRequest { A = 10, B = 5 };
            var divideResponse = await client.DivideAsync(divideRequest);
            Console.WriteLine($"10 / 5 = {divideResponse.Result}");
            
            // 0으로 나누기 시도 (오류 발생)
            var errorRequest = new CalculateRequest { A = 10, B = 0 };
            var errorResponse = await client.DivideAsync(errorRequest);
        }
        catch (Grpc.Core.RpcException ex)
        {
            Console.WriteLine($"gRPC 오류 발생: {ex.Status.Detail}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"오류 발생: {ex.Message}");
        }
        
        Console.WriteLine("엔터를 눌러 종료...");
        Console.ReadLine();
    }
}

보다시피 gRPC 클라이언트 코드는 엄청 간단해! 마치 로컬 메서드를 호출하는 것처럼 자연스럽지? ✨

🎭 gRPC의 4가지 통신 패턴

gRPC의 진짜 강력한 점은 다양한 통신 패턴을 지원한다는 거야. 총 4가지가 있어! 🎪

1. Unary RPC (단일 요청-응답)

가장 기본적인 패턴이야. 클라이언트가 하나의 요청을 보내면 서버가 하나의 응답을 돌려주는 거지. 우리가 위에서 만든 계산기 서비스가 바로 이 패턴이야.

// Proto 정의
rpc GetUser (UserRequest) returns (UserResponse);

2. Server Streaming RPC (서버 스트리밍)

클라이언트가 하나의 요청을 보내면, 서버가 여러 개의 응답을 스트림으로 보내는 패턴이야. 예를 들어 큰 파일을 조각조각 나눠서 보내거나, 실시간 주식 시세를 계속 보낼 때 유용해! 📊

// Proto 정의
rpc GetStockPrices (StockRequest) returns (stream StockPrice);

// 서버 구현
public override async Task GetStockPrices(
    StockRequest request,
    IServerStreamWriter<StockPrice> responseStream,
    ServerCallContext context)
{
    var random = new Random();
    
    // 10초 동안 1초마다 주식 가격 전송
    for (int i = 0; i < 10; i++)
    {
        if (context.CancellationToken.IsCancellationRequested)
            break;
            
        var price = new StockPrice
        {
            Symbol = request.Symbol,
            Price = 50000 + random.Next(-1000, 1000),
            Timestamp = DateTime.UtcNow.ToString()
        };
        
        await responseStream.WriteAsync(price);
        await Task.Delay(1000);
    }
}

// 클라이언트 구현
var request = new StockRequest { Symbol = "AAPL" };
using var call = client.GetStockPrices(request);

await foreach (var price in call.ResponseStream.ReadAllAsync())
{
    Console.WriteLine($"{price.Symbol}: {price.Price}원 ({price.Timestamp})");
}

3. Client Streaming RPC (클라이언트 스트리밍)

반대로 클라이언트가 여러 개의 요청을 스트림으로 보내고, 서버가 하나의 응답을 돌려주는 패턴이야. 대용량 파일 업로드나 센서 데이터 수집에 적합해! 📤

// Proto 정의
rpc UploadFile (stream FileChunk) returns (UploadResult);

// 서버 구현
public override async Task<UploadResult> UploadFile(
    IAsyncStreamReader<FileChunk> requestStream,
    ServerCallContext context)
{
    var fileData = new List<byte>();
    string fileName = "";
    
    await foreach (var chunk in requestStream.ReadAllAsync())
    {
        if (string.IsNullOrEmpty(fileName))
            fileName = chunk.FileName;
            
        fileData.AddRange(chunk.Data.ToByteArray());
    }
    
    // 파일 저장
    await File.WriteAllBytesAsync($"uploads/{fileName}", fileData.ToArray());
    
    return new UploadResult
    {
        Success = true,
        Message = $"{fileName} 업로드 완료 ({fileData.Count} bytes)"
    };
}

// 클라이언트 구현
using var call = client.UploadFile();

var fileBytes = await File.ReadAllBytesAsync("large-file.zip");
int chunkSize = 1024 * 64; // 64KB 청크

for (int i = 0; i < fileBytes.Length; i += chunkSize)
{
    int size = Math.Min(chunkSize, fileBytes.Length - i);
    var chunk = new FileChunk
    {
        FileName = "large-file.zip",
        Data = Google.Protobuf.ByteString.CopyFrom(fileBytes, i, size)
    };
    
    await call.RequestStream.WriteAsync(chunk);
}

await call.RequestStream.CompleteAsync();
var result = await call.ResponseAsync;
Console.WriteLine(result.Message);

4. Bidirectional Streaming RPC (양방향 스트리밍)

가장 강력한 패턴! 클라이언트와 서버가 동시에 스트림으로 데이터를 주고받을 수 있어. 채팅 애플리케이션이나 실시간 게임에 완벽해! 💬

// Proto 정의
rpc Chat (stream ChatMessage) returns (stream ChatMessage);

// 서버 구현
public override async Task Chat(
    IAsyncStreamReader<ChatMessage> requestStream,
    IServerStreamWriter<ChatMessage> responseStream,
    ServerCallContext context)
{
    // 백그라운드에서 클라이언트 메시지 수신
    var readTask = Task.Run(async () =>
    {
        await foreach (var message in requestStream.ReadAllAsync())
        {
            Console.WriteLine($"[{message.User}]: {message.Text}");
            
            // 모든 연결된 클라이언트에게 브로드캐스트
            await BroadcastMessage(message);
        }
    });
    
    // 다른 클라이언트의 메시지를 이 클라이언트에게 전송
    while (!context.CancellationToken.IsCancellationRequested)
    {
        var message = await GetNextBroadcastMessage();
        await responseStream.WriteAsync(message);
    }
    
    await readTask;
}

// 클라이언트 구현
using var call = client.Chat();

// 백그라운드에서 메시지 수신
var receiveTask = Task.Run(async () =>
{
    await foreach (var message in call.ResponseStream.ReadAllAsync())
    {
        Console.WriteLine($"[{message.User}]: {message.Text}");
    }
});

// 메시지 전송
while (true)
{
    var text = Console.ReadLine();
    if (text == "/quit") break;
    
    await call.RequestStream.WriteAsync(new ChatMessage
    {
        User = "홍길동",
        Text = text,
        Timestamp = DateTime.UtcNow.ToString()
    });
}

await call.RequestStream.CompleteAsync();
await receiveTask;

⚖️ WCF vs gRPC: 무엇을 선택할까?

자, 이제 가장 중요한 질문이야. WCF와 gRPC 중에 뭘 써야 할까? 🤔

솔직히 말하면, 새로운 프로젝트라면 거의 대부분 gRPC를 추천해. 하지만 상황에 따라 다를 수 있으니 자세히 비교해보자!

성능 비교: 실제 벤치마크

실제로 얼마나 차이가 날까? 간단한 벤치마크 결과를 보자! 📈

🛡️ 보안과 인증 구현하기

분산 시스템에서 보안은 정말 중요해! 서비스 간 통신이 안전하지 않으면 큰일 나거든. 🔒

WCF와 gRPC 모두 강력한 보안 기능을 제공해. 하나씩 살펴보자!

WCF 보안 설정

WCF는 다양한 보안 모드를 지원해:

// 1. Transport 보안 (HTTPS 사용)
var binding = new WSHttpBinding();
binding.Security.Mode = SecurityMode.Transport;
binding.Security.Transport.ClientCredentialType = 
    HttpClientCredentialType.Windows;

// 2. Message 보안 (메시지 암호화)
var binding2 = new WSHttpBinding();
binding2.Security.Mode = SecurityMode.Message;
binding2.Security.Message.ClientCredentialType = 
    MessageCredentialType.UserName;

// 3. 인증서 기반 보안
var binding3 = new NetTcpBinding();
binding3.Security.Mode = SecurityMode.Transport;
binding3.Security.Transport.ClientCredentialType = 
    TcpClientCredentialType.Certificate;

// 서비스 호스트에 인증서 설정
host.Credentials.ServiceCertificate.SetCertificate(
    StoreLocation.LocalMachine,
    StoreName.My,
    X509FindType.FindBySubjectName,
    "MyServiceCert"
);

클라이언트에서 자격 증명을 제공하는 방법:

// Windows 인증
var client = new CalculatorClient();
client.ClientCredentials.Windows.ClientCredential = 
    new NetworkCredential("username", "password", "domain");

// 사용자 이름/비밀번호 인증
client.ClientCredentials.UserName.UserName = "admin";
client.ClientCredentials.UserName.Password = "P@ssw0rd";

// 인증서 인증
client.ClientCredentials.ClientCertificate.SetCertificate(
    StoreLocation.CurrentUser,
    StoreName.My,
    X509FindType.FindBySubjectName,
    "MyClientCert"
);

gRPC 보안 설정

gRPC는 기본적으로 TLS를 사용한 암호화 통신을 지원해. 설정도 훨씬 간단해! ✨

// 서버: HTTPS 설정 (appsettings.json)
{
  "Kestrel": {
    "Endpoints": {
      "Https": {
        "Url": "https://localhost:5001",
        "Certificate": {
          "Path": "server.pfx",
          "Password": "password"
        }
      }
    }
  }
}

// 클라이언트: TLS 채널 생성
var channel = GrpcChannel.ForAddress("https://localhost:5001", new GrpcChannelOptions
{
    HttpHandler = new HttpClientHandler
    {
        ServerCertificateCustomValidationCallback = 
            HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
    }
});

JWT 토큰 기반 인증도 구현할 수 있어:

// 서버: JWT 인증 설정
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = "MyIssuer",
            ValidAudience = "MyAudience",
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes("MySecretKey12345678"))
        };
    });

builder.Services.AddAuthorization();

var app = builder.Build();
app.UseAuthentication();
app.UseAuthorization();

// 서비스에 인증 요구
[Authorize]
public class SecureCalculatorService : Calculator.CalculatorBase
{
    public override Task<CalculateResponse> Add(
        CalculateRequest request, 
        ServerCallContext context)
    {
        // 사용자 정보 가져오기
        var user = context.GetHttpContext().User;
        var userId = user.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        
        _logger.LogInformation($"User {userId} called Add");
        
        // 비즈니스 로직...
        return Task.FromResult(new CalculateResponse 
        { 
            Result = request.A + request.B 
        });
    }
}

// 클라이언트: JWT 토큰 전송
var token = "eyJhbGciOiJIUzI1NiIs..."; // JWT 토큰

var credentials = CallCredentials.FromInterceptor((context, metadata) =>
{
    metadata.Add("Authorization", $"Bearer {token}");
    return Task.CompletedTask;
});

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var callOptions = new CallOptions(credentials: credentials);

var client = new Calculator.CalculatorClient(channel);
var response = await client.AddAsync(new CalculateRequest { A = 10, B = 5 }, callOptions);

🔧 실전 팁과 베스트 프랙티스

이제 실무에서 정말 유용한 팁들을 공유할게! 이건 내가 직접 삽질하면서 배운 것들이야. 😅

1. 오류 처리와 재시도 로직

분산 시스템에서는 네트워크 오류가 언제든 발생할 수 있어. 재시도 로직은 필수야!

// Polly 라이브러리를 사용한 재시도 정책
using Polly;
using Polly.Extensions.Http;

public static IAsyncPolicy<HttpResponseMessage> GetRetryPolicy()
{
    return HttpPolicyExtensions
        .HandleTransientHttpError()
        .OrResult(msg => msg.StatusCode == System.Net.HttpStatusCode.NotFound)
        .WaitAndRetryAsync(
            retryCount: 3,
            sleepDurationProvider: retryAttempt => 
                TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
            onRetry: (outcome, timespan, retryCount, context) =>
            {
                Console.WriteLine($"재시도 {retryCount}회 ({timespan.TotalSeconds}초 후)");
            });
}

// gRPC 클라이언트에 적용
var channel = GrpcChannel.ForAddress("https://localhost:5001", new GrpcChannelOptions
{
    HttpHandler = new SocketsHttpHandler
    {
        EnableMultipleHttp2Connections = true,
        PooledConnectionIdleTimeout = Timeout.InfiniteTimeSpan,
        KeepAlivePingDelay = TimeSpan.FromSeconds(60),
        KeepAlivePingTimeout = TimeSpan.FromSeconds(30)
    }
});

// 재시도 로직을 포함한 호출
var policy = Policy
    .Handle<RpcException>(ex => 
        ex.StatusCode == StatusCode.Unavailable ||
        ex.StatusCode == StatusCode.DeadlineExceeded)
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: retryAttempt => 
            TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

var client = new Calculator.CalculatorClient(channel);

var response = await policy.ExecuteAsync(async () =>
{
    return await client.AddAsync(
        new CalculateRequest { A = 10, B = 5 },
        deadline: DateTime.UtcNow.AddSeconds(5)
    );
});

2. 로깅과 모니터링

분산 시스템에서는 로깅이 생명줄이야! 각 서비스에서 무슨 일이 일어나는지 추적할 수 있어야 해.

// Serilog를 사용한 구조화된 로깅
using Serilog;

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .WriteTo.Console()
    .WriteTo.File("logs/myservice-.txt", rollingInterval: RollingInterval.Day)
    .WriteTo.Seq("http://localhost:5341") // Seq 서버
    .Enrich.WithProperty("ServiceName", "CalculatorService")
    .Enrich.WithProperty("Environment", "Production")
    .CreateLogger();

// gRPC 인터셉터를 사용한 로깅
public class LoggingInterceptor : Interceptor
{
    private readonly ILogger<LoggingInterceptor> _logger;
    
    public LoggingInterceptor(ILogger<LoggingInterceptor> logger)
    {
        _logger = logger;
    }
    
    public override async Task<TResponse> UnaryServerHandler<TRequest, TResponse>(
        TRequest request,
        ServerCallContext context,
        UnaryServerMethod<TRequest, TResponse> continuation)
    {
        var stopwatch = Stopwatch.StartNew();
        
        _logger.LogInformation(
            "gRPC 요청 시작: {Method} from {Peer}",
            context.Method,
            context.Peer);
        
        try
        {
            var response = await continuation(request, context);
            
            stopwatch.Stop();
            _logger.LogInformation(
                "gRPC 요청 완료: {Method} - {ElapsedMs}ms",
                context.Method,
                stopwatch.ElapsedMilliseconds);
            
            return response;
        }
        catch (Exception ex)
        {
            stopwatch.Stop();
            _logger.LogError(
                ex,
                "gRPC 요청 실패: {Method} - {ElapsedMs}ms",
                context.Method,
                stopwatch.ElapsedMilliseconds);
            
            throw;
        }
    }
}

// 서비스에 인터셉터 등록
builder.Services.AddGrpc(options =>
{
    options.Interceptors.Add<LoggingInterceptor>();
});

3. 성능 최적화

성능을 극대화하기 위한 몇 가지 팁이야:

// 압축 사용 예제
var channel = GrpcChannel.ForAddress("https://localhost:5001", new GrpcChannelOptions
{
    CompressionProviders = new[]
    {
        new GzipCompressionProvider(CompressionLevel.Optimal)
    }
});

var client = new Calculator.CalculatorClient(channel);

// 압축을 사용하여 호출
var response = await client.AddAsync(
    new CalculateRequest { A = 10, B = 5 },
    new CallOptions(
        headers: new Metadata { { "grpc-internal-encoding-request", "gzip" } }
    ));

// 배치 처리 예제
public class BatchCalculatorService : Calculator.CalculatorBase
{
    public override async Task<BatchCalculateResponse> BatchCalculate(
        BatchCalculateRequest request,
        ServerCallContext context)
    {
        var results = new List<double>();
        
        // 병렬 처리로 성능 향상
        var tasks = request.Operations.Select(async op =>
        {
            return op.Operator switch
            {
                "add" => op.A + op.B,
                "subtract" => op.A - op.B,
                "multiply" => op.A * op.B,
                "divide" => op.B != 0 ? (double)op.A / op.B : 0,
                _ => 0
            };
        });
        
        results.AddRange(await Task.WhenAll(tasks));
        
        return new BatchCalculateResponse { Results = { results } };
    }
}

4. 버전 관리와 하위 호환성

서비스를 업데이트할 때 기존 클라이언트가 깨지면 안 돼! Protocol Buffers는 이를 위한 좋은 방법을 제공해.

// 버전 1
message UserRequest {
  int32 id = 1;
}

message UserResponse {
  int32 id = 1;
  string name = 2;
}

// 버전 2 (하위 호환성 유지)
message UserRequest {
  int32 id = 1;
  bool include_details = 2; // 새 필드 추가 (선택적)
}

message UserResponse {
  int32 id = 1;
  string name = 2;
  string email = 3; // 새 필드 추가
  string phone = 4; // 새 필드 추가
  
  // reserved 키워드로 삭제된 필드 번호 보호
  reserved 5, 6;
  reserved "old_field_name";
}

5. 테스트 전략

분산 시스템 테스트는 까다로워. 하지만 제대로 하면 버그를 미리 잡을 수 있어!

// gRPC 서비스 단위 테스트
using Xunit;
using Moq;

public class CalculatorServiceTests
{
    [Fact]
    public async Task Add_ShouldReturnCorrectSum()
    {
        // Arrange
        var mockLogger = new Mock<ILogger<CalculatorServiceImpl>>();
        var service = new CalculatorServiceImpl(mockLogger.Object);
        var request = new CalculateRequest { A = 10, B = 5 };
        var context = TestServerCallContext.Create();
        
        // Act
        var response = await service.Add(request, context);
        
        // Assert
        Assert.Equal(15, response.Result);
        Assert.Equal("덧셈 완료", response.Message);
    }
    
    [Fact]
    public async Task Divide_WithZero_ShouldThrowException()
    {
        // Arrange
        var mockLogger = new Mock<ILogger<CalculatorServiceImpl>>();
        var service = new CalculatorServiceImpl(mockLogger.Object);
        var request = new CalculateRequest { A = 10, B = 0 };
        var context = TestServerCallContext.Create();
        
        // Act & Assert
        await Assert.ThrowsAsync<RpcException>(
            async () => await service.Divide(request, context)
        );
    }
}

// 통합 테스트 (TestServer 사용)
public class CalculatorIntegrationTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly WebApplicationFactory<Program> _factory;
    
    public CalculatorIntegrationTests(WebApplicationFactory<Program> factory)
    {
        _factory = factory;
    }
    
    [Fact]
    public async Task FullWorkflow_ShouldWork()
    {
        // Arrange
        var client = _factory.CreateClient();
        var channel = GrpcChannel.ForAddress(client.BaseAddress, new GrpcChannelOptions
        {
            HttpClient = client
        });
        var grpcClient = new Calculator.CalculatorClient(channel);
        
        // Act
        var response = await grpcClient.AddAsync(new CalculateRequest { A = 10, B = 5 });
        
        // Assert
        Assert.Equal(15, response.Result);
    }
}

🌐 실전 프로젝트: 전자상거래 마이크로서비스

이론만 배우면 재미없지? 실제 프로젝트를 만들어보자! 간단한 전자상거래 시스템을 마이크로서비스로 구현해볼게. 🛒

아키텍처 설계

우리가 만들 시스템은 다음 서비스들로 구성돼:

Product Service 구현

먼저 상품 서비스의 Proto 파일을 정의하자:

// product.proto
syntax = "proto3";

option csharp_namespace = "ECommerce.ProductService";

package product;

service ProductService {
  rpc GetProduct (GetProductRequest) returns (ProductResponse);
  rpc SearchProducts (SearchRequest) returns (ProductListResponse);
  rpc CreateProduct (CreateProductRequest) returns (ProductResponse);
  rpc UpdateStock (UpdateStockRequest) returns (StockResponse);
}

message GetProductRequest {
  string product_id = 1;
}

message SearchRequest {
  string keyword = 1;
  string category = 2;
  int32 page = 3;
  int32 page_size = 4;
}

message ProductResponse {
  string id = 1;
  string name = 2;
  string description = 3;
  double price = 4;
  int32 stock = 5;
  string category = 6;
  repeated string images = 7;
}

message ProductListResponse {
  repeated ProductResponse products = 1;
  int32 total_count = 2;
  int32 page = 3;
}

message CreateProductRequest {
  string name = 1;
  string description = 2;
  double price = 3;
  int32 stock = 4;
  string category = 5;
}

message UpdateStockRequest {
  string product_id = 1;
  int32 quantity = 2;
  string operation = 3; // "add" or "subtract"
}

message StockResponse {
  bool success = 1;
  int32 current_stock = 2;
  string message = 3;
}

서비스 구현:

public class ProductServiceImpl : ProductService.ProductServiceBase
{
    private readonly IProductRepository _repository;
    private readonly ILogger<ProductServiceImpl> _logger;
    
    public ProductServiceImpl(
        IProductRepository repository,
        ILogger<ProductServiceImpl> logger)
    {
        _repository = repository;
        _logger = logger;
    }
    
    public override async Task<ProductResponse> GetProduct(
        GetProductRequest request,
        ServerCallContext context)
    {
        _logger.LogInformation($"상품 조회: {request.ProductId}");
        
        var product = await _repository.GetByIdAsync(request.ProductId);
        
        if (product == null)
        {
            throw new RpcException(new Status(
                StatusCode.NotFound,
                $"상품을 찾을 수 없습니다: {request.ProductId}"
            ));
        }
        
        return MapToResponse(product);
    }
    
    public override async Task<ProductListResponse> SearchProducts(
        SearchRequest request,
        ServerCallContext context)
    {
        _logger.LogInformation(
            $"상품 검색: keyword={request.Keyword}, category={request.Category}");
        
        var (products, totalCount) = await _repository.SearchAsync(
            request.Keyword,
            request.Category,
            request.Page,
            request.PageSize
        );
        
        var response = new ProductListResponse
        {
            TotalCount = totalCount,
            Page = request.Page
        };
        
        response.Products.AddRange(products.Select(MapToResponse));
        
        return response;
    }
    
    public override async Task<ProductResponse> CreateProduct(
        CreateProductRequest request,
        ServerCallContext context)
    {
        _logger.LogInformation($"상품 생성: {request.Name}");
        
        var product = new Product
        {
            Id = Guid.NewGuid().ToString(),
            Name = request.Name,
            Description = request.Description,
            Price = request.Price,
            Stock = request.Stock,
            Category = request.Category,
            CreatedAt = DateTime.UtcNow
        };
        
        await _repository.CreateAsync(product);
        
        return MapToResponse(product);
    }
    
    public override async Task<StockResponse> UpdateStock(
        UpdateStockRequest request,
        ServerCallContext context)
    {
        _logger.LogInformation(
            $"재고 업데이트: {request.ProductId}, {request.Operation} {request.Quantity}");
        
        var product = await _repository.GetByIdAsync(request.ProductId);
        
        if (product == null)
        {
            return new StockResponse
            {
                Success = false,
                Message = "상품을 찾을 수 없습니다"
            };
        }
        
        int newStock = request.Operation.ToLower() == "add"
            ? product.Stock + request.Quantity
            : product.Stock - request.Quantity;
        
        if (newStock < 0)
        {
            return new StockResponse
            {
                Success = false,
                CurrentStock = product.Stock,
                Message = "재고가 부족합니다"
            };
        }
        
        product.Stock = newStock;
        await _repository.UpdateAsync(product);
        
        return new StockResponse
        {
            Success = true,
            CurrentStock = newStock,
            Message = "재고가 업데이트되었습니다"
        };
    }
    
    private ProductResponse MapToResponse(Product product)
    {
        var response = new ProductResponse
        {
            Id = product.Id,
            Name = product.Name,
            Description = product.Description,
            Price = product.Price,
            Stock = product.Stock,
            Category = product.Category
        };
        
        if (product.Images != null)
        {
            response.Images.AddRange(product.Images);
        }
        
        return response;
    }
}

Order Service 구현

주문 서비스는 다른 서비스들과 통신해야 해. 이게 마이크로서비스의 핵심이지!

// order.proto
syntax = "proto3";

option csharp_namespace = "ECommerce.OrderService";

package order;

service OrderService {
  rpc CreateOrder (CreateOrderRequest) returns (OrderResponse);
  rpc GetOrder (GetOrderRequest) returns (OrderResponse);
  rpc GetUserOrders (GetUserOrdersRequest) returns (OrderListResponse);
  rpc CancelOrder (CancelOrderRequest) returns (OrderResponse);
}

message CreateOrderRequest {
  string user_id = 1;
  repeated OrderItem items = 2;
  string shipping_address = 3;
  string payment_method = 4;
}

message OrderItem {
  string product_id = 1;
  int32 quantity = 2;
  double price = 3;
}

message OrderResponse {
  string id = 1;
  string user_id = 2;
  repeated OrderItem items = 3;
  double total_amount = 4;
  string status = 5;
  string shipping_address = 6;
  string created_at = 7;
}

message GetOrderRequest {
  string order_id = 1;
}

message GetUserOrdersRequest {
  string user_id = 1;
  int32 page = 2;
  int32 page_size = 3;
}

message OrderListResponse {
  repeated OrderResponse orders = 1;
  int32 total_count = 2;
}

message CancelOrderRequest {
  string order_id = 1;
  string reason = 2;
}

주문 서비스 구현 (다른 서비스 호출 포함):

public class OrderServiceImpl : OrderService.OrderServiceBase
{
    private readonly IOrderRepository _repository;
    private readonly ProductService.ProductServiceClient _productClient;
    private readonly PaymentService.PaymentServiceClient _paymentClient;
    private readonly NotificationService.NotificationServiceClient _notificationClient;
    private readonly ILogger<OrderServiceImpl> _logger;
    
    public OrderServiceImpl(
        IOrderRepository repository,
        ProductService.ProductServiceClient productClient,
        PaymentService.PaymentServiceClient paymentClient,
        NotificationService.NotificationServiceClient notificationClient,
        ILogger<OrderServiceImpl> logger)
    {
        _repository = repository;
        _productClient = productClient;
        _paymentClient = paymentClient;
        _notificationClient = notificationClient;
        _logger = logger;
    }
    
    public override async Task<OrderResponse> CreateOrder(
        CreateOrderRequest request,
        ServerCallContext context)
    {
        _logger.LogInformation($"주문 생성 시작: User {request.UserId}");
        
        try
        {
            // 1. 상품 재고 확인 및 차감
            foreach (var item in request.Items)
            {
                var stockResponse = await _productClient.UpdateStockAsync(
                    new UpdateStockRequest
                    {
                        ProductId = item.ProductId,
                        Quantity = item.Quantity,
                        Operation = "subtract"
                    });
                
                if (!stockResponse.Success)
                {
                    throw new RpcException(new Status(
                        StatusCode.FailedPrecondition,
                        $"재고 부족: {item.ProductId}"
                    ));
                }
            }
            
            // 2. 주문 생성
            var order = new Order
            {
                Id = Guid.NewGuid().ToString(),
                UserId = request.UserId,
                Items = request.Items.ToList(),
                TotalAmount = request.Items.Sum(i => i.Price * i.Quantity),
                Status = "pending",
                ShippingAddress = request.ShippingAddress,
                CreatedAt = DateTime.UtcNow
            };
            
            await _repository.CreateAsync(order);
            
            // 3. 결제 처리
            var paymentResponse = await _paymentClient.ProcessPaymentAsync(
                new ProcessPaymentRequest
                {
                    OrderId = order.Id,
                    Amount = order.TotalAmount,
                    PaymentMethod = request.PaymentMethod
                });
            
            if (!paymentResponse.Success)
            {
                // 결제 실패 시 재고 복구
                await RollbackStock(request.Items);
                
                throw new RpcException(new Status(
                    StatusCode.Aborted,
                    "결제 처리 실패"
                ));
            }
            
            // 4. 주문 상태 업데이트
            order.Status = "confirmed";
            order.PaymentId = paymentResponse.PaymentId;
            await _repository.UpdateAsync(order);
            
            // 5. 알림 발송 (비동기, 실패해도 주문은 완료)
            _ = Task.Run(async () =>
            {
                try
                {
                    await _notificationClient.SendOrderConfirmationAsync(
                        new SendNotificationRequest
                        {
                            UserId = order.UserId,
                            OrderId = order.Id,
                            Type = "order_confirmation"
                        });
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "알림 발송 실패");
                }
            });
            
            _logger.LogInformation($"주문 생성 완료: {order.Id}");
            
            return MapToResponse(order);
        }
        catch (RpcException)
        {
            throw;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "주문 생성 중 오류 발생");
            throw new RpcException(new Status(
                StatusCode.Internal,
                "주문 처리 중 오류가 발생했습니다"
            ));
        }
    }
    
    private async Task RollbackStock(IEnumerable<OrderItem> items)
    {
        foreach (var item in items)
        {
            try
            {
                await _productClient.UpdateStockAsync(
                    new UpdateStockRequest
                    {
                        ProductId = item.ProductId,
                        Quantity = item.Quantity,
                        Operation = "add"
                    });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"재고 복구 실패: {item.ProductId}");
            }
        }
    }
    
    public override async Task<OrderResponse> CancelOrder(
        CancelOrderRequest request,
        ServerCallContext context)
    {
        _logger.LogInformation($"주문 취소: {request.OrderId}");
        
        var order = await _repository.GetByIdAsync(request.OrderId);
        
        if (order == null)
        {
            throw new RpcException(new Status(
                StatusCode.NotFound,
                "주문을 찾을 수 없습니다"
            ));
        }
        
        if (order.Status == "shipped" || order.Status == "delivered")
        {
            throw new RpcException(new Status(
                StatusCode.FailedPrecondition,
                "배송 중이거나 완료된 주문은 취소할 수 없습니다"
            ));
        }
        
        // 재고 복구
        await RollbackStock(order.Items);
        
        // 환불 처리
        if (!string.IsNullOrEmpty(order.PaymentId))
        {
            await _paymentClient.RefundPaymentAsync(
                new RefundRequest
                {
                    PaymentId = order.PaymentId,
                    Amount = order.TotalAmount,
                    Reason = request.Reason
                });
        }
        
        order.Status = "cancelled";
        order.CancelReason = request.Reason;
        order.CancelledAt = DateTime.UtcNow;
        
        await _repository.UpdateAsync(order);
        
        return MapToResponse(order);
    }
    
    private OrderResponse MapToResponse(Order order)
    {
        var response = new OrderResponse
        {
            Id = order.Id,
            UserId = order.UserId,
            TotalAmount = order.TotalAmount,
            Status = order.Status,
            ShippingAddress = order.ShippingAddress,
            CreatedAt = order.CreatedAt.ToString("o")
        };
        
        response.Items.AddRange(order.Items);
        
        return response;
    }
}

API Gateway 구현

마지막으로 API Gateway를 만들어서 모든 서비스를 하나로 묶자:

// API Gateway (ASP.NET Core)
public class OrderController : ControllerBase
{
    private readonly OrderService.OrderServiceClient _orderClient;
    private readonly ProductService.ProductServiceClient _productClient;
    
    public OrderController(
        OrderService.OrderServiceClient orderClient,
        ProductService.ProductServiceClient productClient)
    {
        _orderClient = orderClient;
        _productClient = productClient;
    }
    
    [HttpPost("api/orders")]
    public async Task<IActionResult> CreateOrder([FromBody] CreateOrderDto dto)
    {
        try
        {
            var request = new CreateOrderRequest
            {
                UserId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value,
                ShippingAddress = dto.ShippingAddress,
                PaymentMethod = dto.PaymentMethod
            };
            
            foreach (var item in dto.Items)
            {
                request.Items.Add(new OrderItem
                {
                    ProductId = item.ProductId,
                    Quantity = item.Quantity,
                    Price = item.Price
                });
            }
            
            var response = await _orderClient.CreateOrderAsync(request);
            
            return Ok(new
            {
                orderId = response.Id,
                totalAmount = response.TotalAmount,
                status = response.Status
            });
        }
        catch (RpcException ex)
        {
            return StatusCode((int)ex.StatusCode, new { error = ex.Status.Detail });
        }
    }
    
    [HttpGet("api/products/search")]
    public async Task<IActionResult> SearchProducts(
        [FromQuery] string keyword,
        [FromQuery] string category,
        [FromQuery] int page = 1,
        [FromQuery] int pageSize = 20)
    {
        var request = new SearchRequest
        {
            Keyword = keyword ?? "",
            Category = category ?? "",
            Page = page,
            PageSize = pageSize
        };
        
        var response = await _productClient.SearchProductsAsync(request);
        
        return Ok(new
        {
            products = response.Products.Select(p => new
            {
                id = p.Id,
                name = p.Name,
                price = p.Price,
                stock = p.Stock,
                category = p.Category
            }),
            totalCount = response.TotalCount,
            page = response.Page
        });
    }
}

// Startup.cs에서 gRPC 클라이언트 등록
public void ConfigureServices(IServiceCollection services)
{
    services.AddGrpcClient<OrderService.OrderServiceClient>(options =>
    {
        options.Address = new Uri("https://order-service:5001");
    });
    
    services.AddGrpcClient<ProductService.ProductServiceClient>(options =>
    {
        options.Address = new Uri("https://product-service:5002");
    });
    
    services.AddGrpcClient<PaymentService.PaymentServiceClient>(options =>
    {
        options.Address = new Uri("https://payment-service:5003");
    });
    
    services.AddControllers();
    services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
        .AddJwtBearer(/* JWT 설정 */);
}

🚀 배포와 운영

개발이 끝났다고 끝이 아니야! 이제 배포하고 운영해야지. 🎯

Docker 컨테이너화

각 서비스를 Docker 컨테이너로 만들면 배포가 훨씬 쉬워져:

# Dockerfile (Product Service)
FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /src
COPY ["ProductService/ProductService.csproj", "ProductService/"]
RUN dotnet restore "ProductService/ProductService.csproj"
COPY . .
WORKDIR "/src/ProductService"
RUN dotnet build "ProductService.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "ProductService.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "ProductService.dll"]

Docker Compose로 모든 서비스를 한 번에 실행:

# docker-compose.yml
version: '3.8'

services:
  product-service:
    build:
      context: .
      dockerfile: ProductService/Dockerfile
    ports:
      - "5002:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
      - ConnectionStrings__Database=Server=db;Database=Products;
    depends_on:
      - db
    networks:
      - ecommerce-network

  order-service:
    build:
      context: .
      dockerfile: OrderService/Dockerfile
    ports:
      - "5001:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
      - ConnectionStrings__Database=Server=db;Database=Orders;
      - Services__ProductService=http://product-service:80
      - Services__PaymentService=http://payment-service:80
    depends_on:
      - db
      - product-service
      - payment-service
    networks:
      - ecommerce-network

  payment-service:
    build:
      context: .
      dockerfile: PaymentService/Dockerfile
    ports:
      - "5003:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
    networks:
      - ecommerce-network

  api-gateway:
    build:
      context: .
      dockerfile: ApiGateway/Dockerfile
    ports:
      - "5000:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
      - Services__OrderService=http://order-service:80
      - Services__ProductService=http://product-service:80
    depends_on:
      - order-service
      - product-service
    networks:
      - ecommerce-network

  db:
    image: postgres:14
    environment:
      - POSTGRES_PASSWORD=yourpassword
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - ecommerce-network

networks:
  ecommerce-network:
    driver: bridge

volumes:
  postgres-data:

Kubernetes 배포

프로덕션 환경에서는 Kubernetes를 사용하면 좋아:

# product-service-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: product-service
  template:
    metadata:
      labels:
        app: product-service
    spec:
      containers:
      - name: product-service
        image: myregistry/product-service:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_ENVIRONMENT
          value: "Production"
        - name: ConnectionStrings__Database
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: connection-string
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: product-service
spec:
  selector:
    app: product-service
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: product-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: product-service
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

💡 마치며: 당신의 분산 시스템 여정

와, 여기까지 왔다니 대단해! 🎉

WCF와 gRPC를 활용한 분산 시스템 구축, 생각보다 복잡하지? 하지만 한 번 제대로 이해하고 나면 정말 강력한 도구가 돼. 특히 요즘처럼 마이크로서비스가 대세인 시대에는 필수 기술이지!

핵심을 정리하자면:

1. WCF는 레거시지만 여전히 많은 곳에서 사용 중
.NET Framework 환경이나 기존 시스템 유지보수에는 필요해.

2. gRPC는 현대적이고 강력한 선택
성능, 스트리밍, 크로스 플랫폼 지원 등 모든 면에서 우수해.

3. 분산 시스템은 단순한 기술이 아니라 아키텍처 사고방식
서비스 분리, 통신 패턴, 오류 처리, 트랜잭션 관리 등 전체적인 설계가 중요해.

4. 실무에서는 이론보다 경험이 중요
직접 만들어보고, 실패하고, 개선하면서 배우는 게 최고야.

분산 시스템 개발은 마라톤이야. 한 번에 모든 걸 완벽하게 만들려고 하지 마. 작은 것부터 시작해서 점진적으로 개선해 나가면 돼. 🏃

그리고 기억해! 기술은 도구일 뿐이야. 진짜 중요한 건 문제를 해결하는 거지. WCF든 gRPC든, 당신의 프로젝트에 맞는 최선의 선택을 하면 돼.

이 글이 당신의 분산 시스템 여정에 도움이 되었길 바라! 궁금한 점이 있거나 더 깊이 배우고 싶다면, 실제로 프로젝트를 만들어보면서 경험을 쌓아봐. 그게 가장 빠른 학습 방법이거든! 💪

행운을 빌어! 멋진 분산 시스템을 만들어보자! 🚀