// Presentation Layer - API Controller
[ApiController]
[Route("api/[controller]")]
public class ProductController : ControllerBase
{
    private readonly IProductService _productService;
    private readonly ILogger<ProductController> _logger;

    public ProductController(
        IProductService productService, 
        ILogger<ProductController> logger)
    {
        _productService = productService;
        _logger = logger;
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetProduct(int id)
    {
        try
        {
            var product = await _productService.GetProductByIdAsync(id);
            if (product == null)
                return NotFound();
            
            return Ok(product);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "상품 조회 중 오류 발생: {ProductId}", id);
            return StatusCode(500, "서버 오류가 발생했습니다.");
        }
    }
}

// Business Logic Layer - Service
public class ProductService : IProductService
{
    private readonly IProductRepository _repository;
    private readonly IMemoryCache _cache;
    private readonly ILogger<ProductService> _logger;

    public ProductService(
        IProductRepository repository,
        IMemoryCache cache,
        ILogger<ProductService> logger)
    {
        _repository = repository;
        _cache = cache;
        _logger = logger;
    }

    public async Task<ProductDto> GetProductByIdAsync(int id)
    {
        // 캐시 확인
        var cacheKey = $"product_{id}";
        if (_cache.TryGetValue(cacheKey, out ProductDto cachedProduct))
        {
            _logger.LogInformation("캐시에서 상품 조회: {ProductId}", id);
            return cachedProduct;
        }

        // DB에서 조회
        var product = await _repository.GetByIdAsync(id);
        if (product == null)
            return null;

        var productDto = MapToDto(product);

        // 캐시에 저장 (10분)
        _cache.Set(cacheKey, productDto, TimeSpan.FromMinutes(10));

        return productDto;
    }

    private ProductDto MapToDto(Product product)
    {
        return new ProductDto
        {
            Id = product.Id,
            Name = product.Name,
            Price = product.Price,
            Stock = product.Stock
        };
    }
}

// Data Access Layer - Repository
public class ProductRepository : IProductRepository
{
    private readonly ApplicationDbContext _context;

    public ProductRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<Product> GetByIdAsync(int id)
    {
        return await _context.Products
            .AsNoTracking()
            .FirstOrDefaultAsync(p => p.Id == id);
    }

    public async Task<IEnumerable<Product>> GetAllAsync()
    {
        return await _context.Products
            .AsNoTracking()
            .ToListAsync();
    }

    public async Task<Product> AddAsync(Product product)
    {
        _context.Products.Add(product);
        await _context.SaveChangesAsync();
        return product;
    }
}

// Program.cs 또는 Startup.cs에서 서비스 등록
public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        // 서비스 등록
        builder.Services.AddControllers();
        
        // 데이터베이스 컨텍스트 등록
        builder.Services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(
                builder.Configuration.GetConnectionString("DefaultConnection")));

        // 레포지토리 등록
        builder.Services.AddScoped<IProductRepository, ProductRepository>();
        builder.Services.AddScoped<IOrderRepository, OrderRepository>();

        // 서비스 등록
        builder.Services.AddScoped<IProductService, ProductService>();
        builder.Services.AddScoped<IOrderService, OrderService>();

        // 캐싱
        builder.Services.AddMemoryCache();
        builder.Services.AddDistributedMemoryCache();

        // Redis 캐시 (프로덕션 환경)
        // builder.Services.AddStackExchangeRedisCache(options =>
        // {
        //     options.Configuration = builder.Configuration
        //         .GetConnectionString("Redis");
        // });

        // 로깅
        builder.Services.AddLogging(logging =>
        {
            logging.AddConsole();
            logging.AddDebug();
        });

        var app = builder.Build();

        app.UseHttpsRedirection();
        app.UseAuthorization();
        app.MapControllers();

        app.Run();
    }
}

// Command 모델
public class CreateProductCommand
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
}

public class CreateProductCommandHandler
{
    private readonly ApplicationDbContext _context;
    private readonly IEventPublisher _eventPublisher;

    public CreateProductCommandHandler(
        ApplicationDbContext context,
        IEventPublisher eventPublisher)
    {
        _context = context;
        _eventPublisher = eventPublisher;
    }

    public async Task<int> HandleAsync(CreateProductCommand command)
    {
        var product = new Product
        {
            Name = command.Name,
            Price = command.Price,
            Stock = command.Stock,
            CreatedAt = DateTime.UtcNow
        };

        _context.Products.Add(product);
        await _context.SaveChangesAsync();

        // 이벤트 발행 (다른 서비스에 알림)
        await _eventPublisher.PublishAsync(new ProductCreatedEvent
        {
            ProductId = product.Id,
            Name = product.Name
        });

        return product.Id;
    }
}

// Query 모델
public class GetProductQuery
{
    public int Id { get; set; }
}

public class GetProductQueryHandler
{
    private readonly IReadOnlyDbContext _readContext;
    private readonly IMemoryCache _cache;

    public GetProductQueryHandler(
        IReadOnlyDbContext readContext,
        IMemoryCache cache)
    {
        _readContext = readContext;
        _cache = cache;
    }

    public async Task<ProductReadModel> HandleAsync(GetProductQuery query)
    {
        var cacheKey = $"product_read_{query.Id}";
        
        if (_cache.TryGetValue(cacheKey, out ProductReadModel cached))
            return cached;

        // 읽기 전용 DB에서 조회 (복제본 또는 읽기 최적화된 DB)
        var product = await _readContext.Products
            .AsNoTracking()
            .Where(p => p.Id == query.Id)
            .Select(p => new ProductReadModel
            {
                Id = p.Id,
                Name = p.Name,
                Price = p.Price,
                Stock = p.Stock,
                CategoryName = p.Category.Name,
                ReviewCount = p.Reviews.Count,
                AverageRating = p.Reviews.Average(r => r.Rating)
            })
            .FirstOrDefaultAsync();

        if (product != null)
        {
            _cache.Set(cacheKey, product, TimeSpan.FromMinutes(15));
        }

        return product;
    }
}

// 읽기 최적화된 모델
public class ProductReadModel
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
    public string CategoryName { get; set; }
    public int ReviewCount { get; set; }
    public double AverageRating { get; set; }
}

// 이벤트 정의
public class OrderCreatedEvent
{
    public int OrderId { get; set; }
    public int UserId { get; set; }
    public List<OrderItem> Items { get; set; }
    public decimal TotalAmount { get; set; }
    public DateTime CreatedAt { get; set; }
}

// 주문 서비스
public class OrderService
{
    private readonly IOrderRepository _orderRepository;
    private readonly IEventBus _eventBus;

    public async Task<int> CreateOrderAsync(CreateOrderDto dto)
    {
        // 주문 생성
        var order = new Order
        {
            UserId = dto.UserId,
            Items = dto.Items,
            TotalAmount = dto.Items.Sum(i => i.Price * i.Quantity),
            Status = OrderStatus.Pending,
            CreatedAt = DateTime.UtcNow
        };

        await _orderRepository.AddAsync(order);

        // 이벤트 발행 (비동기)
        await _eventBus.PublishAsync(new OrderCreatedEvent
        {
            OrderId = order.Id,
            UserId = order.UserId,
            Items = order.Items,
            TotalAmount = order.TotalAmount,
            CreatedAt = order.CreatedAt
        });

        return order.Id;
    }
}

// 재고 서비스 - 이벤트 핸들러
public class InventoryEventHandler : IEventHandler<OrderCreatedEvent>
{
    private readonly IInventoryService _inventoryService;
    private readonly ILogger<InventoryEventHandler> _logger;

    public async Task HandleAsync(OrderCreatedEvent @event)
    {
        try
        {
            foreach (var item in @event.Items)
            {
                await _inventoryService.DecreaseStockAsync(
                    item.ProductId, 
                    item.Quantity);
            }
            
            _logger.LogInformation(
                "재고 감소 완료: OrderId={OrderId}", 
                @event.OrderId);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, 
                "재고 감소 실패: OrderId={OrderId}", 
                @event.OrderId);
            
            // 보상 트랜잭션 또는 재시도 로직
            throw;
        }
    }
}

// 이메일 서비스 - 이벤트 핸들러
public class EmailEventHandler : IEventHandler<OrderCreatedEvent>
{
    private readonly IEmailService _emailService;
    private readonly IUserRepository _userRepository;

    public async Task HandleAsync(OrderCreatedEvent @event)
    {
        var user = await _userRepository.GetByIdAsync(@event.UserId);
        
        await _emailService.SendOrderConfirmationAsync(
            user.Email,
            @event.OrderId,
            @event.Items,
            @event.TotalAmount);
    }
}

// MassTransit을 사용한 이벤트 버스 설정
public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        builder.Services.AddMassTransit(x =>
        {
            // 컨슈머 등록
            x.AddConsumer<InventoryEventHandler>();
            x.AddConsumer<EmailEventHandler>();

            // RabbitMQ 설정
            x.UsingRabbitMq((context, cfg) =>
            {
                cfg.Host("rabbitmq://localhost", h =>
                {
                    h.Username("guest");
                    h.Password("guest");
                });

                cfg.ConfigureEndpoints(context);
            });
        });

        var app = builder.Build();
        app.Run();
    }
}

// Redis 분산 캐시 구현
public class RedisCacheService : ICacheService
{
    private readonly IDistributedCache _cache;
    private readonly ILogger<RedisCacheService> _logger;

    public RedisCacheService(
        IDistributedCache cache,
        ILogger<RedisCacheService> logger)
    {
        _cache = cache;
        _logger = logger;
    }

    public async Task<T> GetOrCreateAsync<T>(
        string key,
        Func<Task<T>> factory,
        TimeSpan? expiration = null)
    {
        // 캐시에서 조회
        var cachedData = await _cache.GetStringAsync(key);
        
        if (!string.IsNullOrEmpty(cachedData))
        {
            _logger.LogDebug("캐시 히트: {Key}", key);
            return JsonSerializer.Deserialize<T>(cachedData);
        }

        // 캐시 미스 - 데이터 생성
        _logger.LogDebug("캐시 미스: {Key}", key);
        var data = await factory();

        if (data != null)
        {
            var serialized = JsonSerializer.Serialize(data);
            var options = new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = 
                    expiration ?? TimeSpan.FromMinutes(10)
            };

            await _cache.SetStringAsync(key, serialized, options);
        }

        return data;
    }

    public async Task RemoveAsync(string key)
    {
        await _cache.RemoveAsync(key);
        _logger.LogDebug("캐시 삭제: {Key}", key);
    }

    public async Task RemoveByPrefixAsync(string prefix)
    {
        // Redis의 SCAN 명령을 사용하여 패턴 매칭
        // 실제 구현은 StackExchange.Redis를 직접 사용
        _logger.LogDebug("캐시 패턴 삭제: {Prefix}*", prefix);
    }
}

// 캐시 활용 예제
public class ProductService
{
    private readonly IProductRepository _repository;
    private readonly ICacheService _cache;

    public async Task<ProductDto> GetProductAsync(int id)
    {
        return await _cache.GetOrCreateAsync(
            $"product:{id}",
            async () =>
            {
                var product = await _repository.GetByIdAsync(id);
                return product != null ? MapToDto(product) : null;
            },
            TimeSpan.FromMinutes(30)
        );
    }

    public async Task<List<ProductDto>> GetPopularProductsAsync()
    {
        return await _cache.GetOrCreateAsync(
            "products:popular",
            async () =>
            {
                var products = await _repository
                    .GetPopularProductsAsync(limit: 20);
                return products.Select(MapToDto).ToList();
            },
            TimeSpan.FromMinutes(5) // 인기 상품은 자주 갱신
        );
    }

    public async Task UpdateProductAsync(int id, UpdateProductDto dto)
    {
        await _repository.UpdateAsync(id, dto);
        
        // 캐시 무효화
        await _cache.RemoveAsync($"product:{id}");
        await _cache.RemoveAsync("products:popular");
    }
}

// YARP를 사용한 API Gateway 설정
// appsettings.json
{
  "ReverseProxy": {
    "Routes": {
      "product-route": {
        "ClusterId": "product-cluster",
        "Match": {
          "Path": "/api/products/{**catch-all}"
        },
        "Transforms": [
          { "PathPattern": "/api/products/{**catch-all}" }
        ]
      },
      "order-route": {
        "ClusterId": "order-cluster",
        "Match": {
          "Path": "/api/orders/{**catch-all}"
        }
      },
      "user-route": {
        "ClusterId": "user-cluster",
        "Match": {
          "Path": "/api/users/{**catch-all}"
        }
      }
    },
    "Clusters": {
      "product-cluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://product-service:5001"
          },
          "destination2": {
            "Address": "https://product-service:5002"
          }
        },
        "LoadBalancingPolicy": "RoundRobin"
      },
      "order-cluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://order-service:5003"
          }
        }
      },
      "user-cluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://user-service:5004"
          }
        }
      }
    }
  }
}

// JWT 기반 인증 구현
public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        // JWT 인증 설정
        builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
            .AddJwtBearer(options =>
            {
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidateIssuer = true,
                    ValidateAudience = true,
                    ValidateLifetime = true,
                    ValidateIssuerSigningKey = true,
                    ValidIssuer = builder.Configuration["Jwt:Issuer"],
                    ValidAudience = builder.Configuration["Jwt:Audience"],
                    IssuerSigningKey = new SymmetricSecurityKey(
                        Encoding.UTF8.GetBytes(
                            builder.Configuration["Jwt:Key"]))
                };
            });

        // 권한 정책 설정
        builder.Services.AddAuthorization(options =>
        {
            options.AddPolicy("AdminOnly", policy =>
                policy.RequireRole("Admin"));
            
            options.AddPolicy("UserOrAdmin", policy =>
                policy.RequireRole("User", "Admin"));
        });

        // YARP 추가
        builder.Services.AddReverseProxy()
            .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));

        var app = builder.Build();

        app.UseAuthentication();
        app.UseAuthorization();
        
        app.MapReverseProxy();

        app.Run();
    }
}

// JWT 토큰 생성 서비스
public class TokenService : ITokenService
{
    private readonly IConfiguration _configuration;

    public TokenService(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public string GenerateToken(User user)
    {
        var securityKey = new SymmetricSecurityKey(
            Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]));
        
        var credentials = new SigningCredentials(
            securityKey, 
            SecurityAlgorithms.HmacSha256);

        var claims = new[]
        {
            new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
            new Claim(ClaimTypes.Name, user.Username),
            new Claim(ClaimTypes.Email, user.Email),
            new Claim(ClaimTypes.Role, user.Role),
            new Claim("premium", user.IsPremium.ToString())
        };

        var token = new JwtSecurityToken(
            issuer: _configuration["Jwt:Issuer"],
            audience: _configuration["Jwt:Audience"],
            claims: claims,
            expires: DateTime.Now.AddHours(24),
            signingCredentials: credentials);

        return new JwtSecurityTokenHandler().WriteToken(token);
    }

    public ClaimsPrincipal ValidateToken(string token)
    {
        var tokenHandler = new JwtSecurityTokenHandler();
        var key = Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]);

        try
        {
            var principal = tokenHandler.ValidateToken(token, 
                new TokenValidationParameters
                {
                    ValidateIssuerSigningKey = true,
                    IssuerSigningKey = new SymmetricSecurityKey(key),
                    ValidateIssuer = true,
                    ValidIssuer = _configuration["Jwt:Issuer"],
                    ValidateAudience = true,
                    ValidAudience = _configuration["Jwt:Audience"],
                    ValidateLifetime = true,
                    ClockSkew = TimeSpan.Zero
                }, 
                out SecurityToken validatedToken);

            return principal;
        }
        catch
        {
            return null;
        }
    }
}

// Serilog를 사용한 구조화된 로깅
public class Program
{
    public static void Main(string[] args)
    {
        // Serilog 설정
        Log.Logger = new LoggerConfiguration()
            .MinimumLevel.Information()
            .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
            .Enrich.FromLogContext()
            .Enrich.WithMachineName()
            .Enrich.WithEnvironmentName()
            .WriteTo.Console(
                outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
            .WriteTo.File(
                path: "logs/app-.txt",
                rollingInterval: RollingInterval.Day,
                retainedFileCountLimit: 30)
            .WriteTo.Seq("http://localhost:5341") // Seq 로그 서버
            .CreateLogger();

        try
        {
            Log.Information("애플리케이션 시작");
            CreateHostBuilder(args).Build().Run();
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, "애플리케이션 시작 실패");
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .UseSerilog()
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

// 성능 측정 미들웨어
public class PerformanceMonitoringMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<PerformanceMonitoringMiddleware> _logger;
    private readonly IMetricsService _metrics;

    public PerformanceMonitoringMiddleware(
        RequestDelegate next,
        ILogger<PerformanceMonitoringMiddleware> logger,
        IMetricsService metrics)
    {
        _next = next;
        _logger = logger;
        _metrics = metrics;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var sw = Stopwatch.StartNew();
        var path = context.Request.Path;
        var method = context.Request.Method;

        try
        {
            await _next(context);
            sw.Stop();

            var statusCode = context.Response.StatusCode;
            var duration = sw.ElapsedMilliseconds;

            // 메트릭 기록
            _metrics.RecordRequestDuration(path, method, statusCode, duration);

            // 느린 요청 로깅
            if (duration > 1000)
            {
                _logger.LogWarning(
                    "느린 요청 감지: {Method} {Path} - {Duration}ms, Status: {StatusCode}",
                    method, path, duration, statusCode);
            }

            // 구조화된 로그
            _logger.LogInformation(
                "HTTP {Method} {Path} responded {StatusCode} in {Duration}ms",
                method, path, statusCode, duration);
        }
        catch (Exception ex)
        {
            sw.Stop();
            
            _logger.LogError(ex,
                "요청 처리 중 오류: {Method} {Path} - {Duration}ms",
                method, path, sw.ElapsedMilliseconds);

            _metrics.RecordError(path, method, ex.GetType().Name);
            
            throw;
        }
    }
}

// Application Insights 통합
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Application Insights 추가
        services.AddApplicationInsightsTelemetry(options =>
        {
            options.ConnectionString = Configuration["ApplicationInsights:ConnectionString"];
            options.EnableAdaptiveSampling = true;
            options.EnableQuickPulseMetricStream = true;
        });

        // 커스텀 텔레메트리 초기화
        services.AddSingleton<ITelemetryInitializer, CustomTelemetryInitializer>();

        // 헬스 체크
        services.AddHealthChecks()
            .AddDbContextCheck<ApplicationDbContext>()
            .AddRedis(Configuration["Redis:ConnectionString"])
            .AddUrlGroup(new Uri("https://external-api.com/health"), "External API");
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseMiddleware<PerformanceMonitoringMiddleware>();
        
        // 헬스 체크 엔드포인트
        app.UseHealthChecks("/health", new HealthCheckOptions
        {
            ResponseWriter = async (context, report) =>
            {
                context.Response.ContentType = "application/json";
                var result = JsonSerializer.Serialize(new
                {
                    status = report.Status.ToString(),
                    checks = report.Entries.Select(e => new
                    {
                        name = e.Key,
                        status = e.Value.Status.ToString(),
                        duration = e.Value.Duration.TotalMilliseconds,
                        description = e.Value.Description
                    }),
                    totalDuration = report.TotalDuration.TotalMilliseconds
                });
                await context.Response.WriteAsync(result);
            }
        });
    }
}

# Dockerfile - ASP.NET Core 애플리케이션
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["ProductService/ProductService.csproj", "ProductService/"]
COPY ["Common/Common.csproj", "Common/"]
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.yml - 로컬 개발 환경
version: '3.8'

services:
  product-service:
    build:
      context: .
      dockerfile: ProductService/Dockerfile
    ports:
      - "5001:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
      - ConnectionStrings__DefaultConnection=Server=sqlserver;Database=ProductDb;User=sa;Password=YourPassword123;
      - Redis__ConnectionString=redis:6379
    depends_on:
      - sqlserver
      - redis
    networks:
      - app-network

  order-service:
    build:
      context: .
      dockerfile: OrderService/Dockerfile
    ports:
      - "5002:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
      - ConnectionStrings__DefaultConnection=Server=sqlserver;Database=OrderDb;User=sa;Password=YourPassword123;
      - RabbitMQ__Host=rabbitmq
    depends_on:
      - sqlserver
      - rabbitmq
    networks:
      - app-network

  api-gateway:
    build:
      context: .
      dockerfile: ApiGateway/Dockerfile
    ports:
      - "5000:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
    depends_on:
      - product-service
      - order-service
    networks:
      - app-network

  sqlserver:
    image: mcr.microsoft.com/mssql/server:2022-latest
    environment:
      - ACCEPT_EULA=Y
      - SA_PASSWORD=YourPassword123
    ports:
      - "1433:1433"
    volumes:
      - sqlserver-data:/var/opt/mssql
    networks:
      - app-network

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    networks:
      - app-network

  rabbitmq:
    image: rabbitmq:3-management-alpine
    ports:
      - "5672:5672"
      - "15672:15672"
    environment:
      - RABBITMQ_DEFAULT_USER=guest
      - RABBITMQ_DEFAULT_PASS=guest
    volumes:
      - rabbitmq-data:/var/lib/rabbitmq
    networks:
      - app-network

volumes:
  sqlserver-data:
  redis-data:
  rabbitmq-data:

networks:
  app-network:
    driver: bridge

# Kubernetes Deployment - 프로덕션 환경
apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
  labels:
    app: product-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: product-service
  template:
    metadata:
      labels:
        app: product-service
    spec:
      containers:
      - name: product-service
        image: myregistry.azurecr.io/product-service:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_ENVIRONMENT
          value: "Production"
        - name: ConnectionStrings__DefaultConnection
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: connection-string
        - name: Redis__ConnectionString
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: redis-connection
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health/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: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

// 읽기/쓰기 분리 구현
public class DbContextFactory
{
    private readonly string _writeConnectionString;
    private readonly string _readConnectionString;

    public DbContextFactory(IConfiguration configuration)
    {
        _writeConnectionString = configuration
            .GetConnectionString("WriteConnection");
        _readConnectionString = configuration
            .GetConnectionString("ReadConnection");
    }

    public ApplicationDbContext CreateWriteContext()
    {
        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
            .UseSqlServer(_writeConnectionString)
            .Options;

        return new ApplicationDbContext(options);
    }

    public ApplicationDbContext CreateReadContext()
    {
        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
            .UseSqlServer(_readConnectionString)
            .UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking)
            .Options;

        return new ApplicationDbContext(options);
    }
}

// Repository에서 활용
public class ProductRepository : IProductRepository
{
    private readonly DbContextFactory _contextFactory;

    public ProductRepository(DbContextFactory contextFactory)
    {
        _contextFactory = contextFactory;
    }

    // 읽기 작업 - 읽기 전용 DB 사용
    public async Task<Product> GetByIdAsync(int id)
    {
        using var context = _contextFactory.CreateReadContext();
        return await context.Products
            .AsNoTracking()
            .FirstOrDefaultAsync(p => p.Id == id);
    }

    public async Task<List<Product>> GetAllAsync()
    {
        using var context = _contextFactory.CreateReadContext();
        return await context.Products
            .AsNoTracking()
            .ToListAsync();
    }

    // 쓰기 작업 - 마스터 DB 사용
    public async Task<Product> AddAsync(Product product)
    {
        using var context = _contextFactory.CreateWriteContext();
        context.Products.Add(product);
        await context.SaveChangesAsync();
        return product;
    }

    public async Task UpdateAsync(Product product)
    {
        using var context = _contextFactory.CreateWriteContext();
        context.Products.Update(product);
        await context.SaveChangesAsync();
    }
}

// 샤딩 구현 예제
public class ShardedProductRepository : IProductRepository
{
    private readonly List<DbContextFactory> _shards;
    private readonly ILogger<ShardedProductRepository> _logger;

    public ShardedProductRepository(
        IConfiguration configuration,
        ILogger<ShardedProductRepository> logger)
    {
        _logger = logger;
        _shards = new List<DbContextFactory>();

        // 여러 샤드 초기화
        var shardCount = configuration.GetValue<int>("Database:ShardCount");
        for (int i = 0; i < shardCount; i++)
        {
            var connectionString = configuration
                .GetConnectionString($"Shard{i}");
            _shards.Add(new DbContextFactory(connectionString));
        }
    }

    private int GetShardIndex(int productId)
    {
        // 간단한 해시 기반 샤딩
        return productId % _shards.Count;
    }

    public async Task<Product> GetByIdAsync(int id)
    {
        var shardIndex = GetShardIndex(id);
        using var context = _shards[shardIndex].CreateReadContext();
        
        _logger.LogDebug("샤드 {ShardIndex}에서 상품 조회: {ProductId}", 
            shardIndex, id);

        return await context.Products
            .AsNoTracking()
            .FirstOrDefaultAsync(p => p.Id == id);
    }

    public async Task<List<Product>> GetAllAsync()
    {
        // 모든 샤드에서 데이터 조회
        var tasks = _shards.Select(async (shard, index) =>
        {
            using var context = shard.CreateReadContext();
            _logger.LogDebug("샤드 {ShardIndex}에서 전체 상품 조회", index);
            return await context.Products.AsNoTracking().ToListAsync();
        });

        var results = await Task.WhenAll(tasks);
        return results.SelectMany(r => r).ToList();
    }

    public async Task<Product> AddAsync(Product product)
    {
        var shardIndex = GetShardIndex(product.Id);
        using var context = _shards[shardIndex].CreateWriteContext();
        
        _logger.LogInformation("샤드 {ShardIndex}에 상품 추가: {ProductId}", 
            shardIndex, product.Id);

        context.Products.Add(product);
        await context.SaveChangesAsync();
        return product;
    }
}

// Rate Limiting 구현 (AspNetCoreRateLimit 사용)
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Rate Limiting 설정
        services.AddMemoryCache();
        services.Configure<IpRateLimitOptions>(Configuration.GetSection("IpRateLimiting"));
        services.Configure<IpRateLimitPolicies>(Configuration.GetSection("IpRateLimitPolicies"));
        services.AddInMemoryRateLimiting();
        services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseIpRateLimiting();
    }
}

// appsettings.json
{
  "IpRateLimiting": {
    "EnableEndpointRateLimiting": true,
    "StackBlockedRequests": false,
    "RealIpHeader": "X-Real-IP",
    "ClientIdHeader": "X-ClientId",
    "HttpStatusCode": 429,
    "GeneralRules": [
      {
        "Endpoint": "*",
        "Period": "1s",
        "Limit": 10
      },
      {
        "Endpoint": "*",
        "Period": "1m",
        "Limit": 100
      },
      {
        "Endpoint": "*/api/products",
        "Period": "1s",
        "Limit": 20
      }
    ]
  }
}

// Circuit Breaker 구현 (Polly 사용)
public class ExternalApiService
{
    private readonly HttpClient _httpClient;
    private readonly IAsyncPolicy<HttpResponseMessage> _circuitBreakerPolicy;
    private readonly ILogger<ExternalApiService> _logger;

    public ExternalApiService(
        HttpClient httpClient,
        ILogger<ExternalApiService> logger)
    {
        _httpClient = httpClient;
        _logger = logger;

        // Circuit Breaker 정책 설정
        _circuitBreakerPolicy = Policy
            .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .Or<HttpRequestException>()
            .CircuitBreakerAsync(
                handledEventsAllowedBeforeBreaking: 3,
                durationOfBreak: TimeSpan.FromSeconds(30),
                onBreak: (result, duration) =>
                {
                    _logger.LogWarning(
                        "Circuit Breaker 열림: {Duration}초 동안 차단됨", 
                        duration.TotalSeconds);
                },
                onReset: () =>
                {
                    _logger.LogInformation("Circuit Breaker 리셋됨");
                },
                onHalfOpen: () =>
                {
                    _logger.LogInformation("Circuit Breaker Half-Open 상태");
                });
    }

    public async Task<ExternalData> GetDataAsync(string id)
    {
        try
        {
            var response = await _circuitBreakerPolicy.ExecuteAsync(async () =>
            {
                _logger.LogDebug("외부 API 호출: {Id}", id);
                return await _httpClient.GetAsync($"/api/data/{id}");
            });

            if (response.IsSuccessStatusCode)
            {
                var content = await response.Content.ReadAsStringAsync();
                return JsonSerializer.Deserialize<ExternalData>(content);
            }

            _logger.LogWarning(
                "외부 API 호출 실패: {StatusCode}", 
                response.StatusCode);
            return null;
        }
        catch (BrokenCircuitException ex)
        {
            _logger.LogError(ex, "Circuit Breaker가 열려있어 요청 차단됨");
            // Fallback 데이터 반환 또는 캐시된 데이터 사용
            return GetFallbackData(id);
        }
    }

    private ExternalData GetFallbackData(string id)
    {
        // 캐시된 데이터나 기본값 반환
        return new ExternalData { Id = id, Status = "Unavailable" };
    }
}

// 종합적인 Resilience 정책
public static class ResiliencePolicies
{
    public static IAsyncPolicy<HttpResponseMessage> GetRetryPolicy(
        ILogger logger)
    {
        return Policy
            .HandleResult<HttpResponseMessage>(r => 
                r.StatusCode == System.Net.HttpStatusCode.RequestTimeout ||
                r.StatusCode == System.Net.HttpStatusCode.ServiceUnavailable)
            .Or<HttpRequestException>()
            .WaitAndRetryAsync(
                retryCount: 3,
                sleepDurationProvider: retryAttempt => 
                    TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
                onRetry: (outcome, timespan, retryCount, context) =>
                {
                    logger.LogWarning(
                        "재시도 {RetryCount}: {Timespan}초 후 재시도",
                        retryCount, timespan.TotalSeconds);
                });
    }

    public static IAsyncPolicy<HttpResponseMessage> GetCircuitBreakerPolicy(
        ILogger logger)
    {
        return Policy
            .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .Or<HttpRequestException>()
            .AdvancedCircuitBreakerAsync(
                failureThreshold: 0.5,
                samplingDuration: TimeSpan.FromSeconds(10),
                minimumThroughput: 8,
                durationOfBreak: TimeSpan.FromSeconds(30),
                onBreak: (result, duration) =>
                {
                    logger.LogWarning("Circuit Breaker 열림");
                },
                onReset: () =>
                {
                    logger.LogInformation("Circuit Breaker 리셋");
                });
    }

    public static IAsyncPolicy<HttpResponseMessage> GetTimeoutPolicy()
    {
        return Policy.TimeoutAsync<HttpResponseMessage>(
            TimeSpan.FromSeconds(10));
    }

    public static IAsyncPolicy<HttpResponseMessage> GetCombinedPolicy(
        ILogger logger)
    {
        var retry = GetRetryPolicy(logger);
        var circuitBreaker = GetCircuitBreakerPolicy(logger);
        var timeout = GetTimeoutPolicy();

        // 정책 조합: Timeout -> Retry -> Circuit Breaker
        return Policy.WrapAsync(timeout, retry, circuitBreaker);
    }
}

// RabbitMQ를 사용한 메시지 발행
public class OrderService
{
    private readonly IOrderRepository _repository;
    private readonly IMessagePublisher _messagePublisher;
    private readonly ILogger<OrderService> _logger;

    public async Task<Order> CreateOrderAsync(CreateOrderDto dto)
    {
        // 주문 생성
        var order = new Order
        {
            UserId = dto.UserId,
            Items = dto.Items,
            TotalAmount = CalculateTotal(dto.Items),
            Status = OrderStatus.Pending,
            CreatedAt = DateTime.UtcNow
        };

        await _repository.AddAsync(order);
        _logger.LogInformation("주문 생성됨: {OrderId}", order.Id);

        // 메시지 발행 (비동기 처리)
        await _messagePublisher.PublishAsync(new OrderCreatedMessage
        {
            OrderId = order.Id,
            UserId = order.UserId,
            Items = order.Items.Select(i => new OrderItemMessage
            {
                ProductId = i.ProductId,
                Quantity = i.Quantity,
                Price = i.Price
            }).ToList(),
            TotalAmount = order.TotalAmount,
            CreatedAt = order.CreatedAt
        });

        return order;
    }
}

// 메시지 발행자
public class RabbitMqPublisher : IMessagePublisher
{
    private readonly IConnection _connection;
    private readonly IModel _channel;
    private readonly ILogger<RabbitMqPublisher> _logger;

    public RabbitMqPublisher(
        IConfiguration configuration,
        ILogger<RabbitMqPublisher> logger)
    {
        _logger = logger;
        
        var factory = new ConnectionFactory
        {
            HostName = configuration["RabbitMQ:Host"],
            UserName = configuration["RabbitMQ:Username"],
            Password = configuration["RabbitMQ:Password"],
            VirtualHost = configuration["RabbitMQ:VirtualHost"]
        };

        _connection = factory.CreateConnection();
        _channel = _connection.CreateModel();

        // Exchange 선언
        _channel.ExchangeDeclare(
            exchange: "orders",
            type: ExchangeType.Topic,
            durable: true);
    }

    public async Task PublishAsync<T>(T message, string routingKey = "")
    {
        var json = JsonSerializer.Serialize(message);
        var body = Encoding.UTF8.GetBytes(json);

        var properties = _channel.CreateBasicProperties();
        properties.Persistent = true;
        properties.ContentType = "application/json";
        properties.MessageId = Guid.NewGuid().ToString();
        properties.Timestamp = new AmqpTimestamp(
            DateTimeOffset.UtcNow.ToUnixTimeSeconds());

        _channel.BasicPublish(
            exchange: "orders",
            routingKey: routingKey,
            basicProperties: properties,
            body: body);

        _logger.LogDebug(
            "메시지 발행됨: {MessageType}, RoutingKey: {RoutingKey}",
            typeof(T).Name, routingKey);

        await Task.CompletedTask;
    }
}

// 메시지 소비자 (Worker Service)
public class OrderMessageConsumer : BackgroundService
{
    private readonly IConnection _connection;
    private readonly IModel _channel;
    private readonly IServiceProvider _serviceProvider;
    private readonly ILogger<OrderMessageConsumer> _logger;

    public OrderMessageConsumer(
        IConfiguration configuration,
        IServiceProvider serviceProvider,
        ILogger<OrderMessageConsumer> logger)
    {
        _serviceProvider = serviceProvider;
        _logger = logger;

        var factory = new ConnectionFactory
        {
            HostName = configuration["RabbitMQ:Host"],
            UserName = configuration["RabbitMQ:Username"],
            Password = configuration["RabbitMQ:Password"]
        };

        _connection = factory.CreateConnection();
        _channel = _connection.CreateModel();

        // Queue 선언
        _channel.QueueDeclare(
            queue: "order-processing",
            durable: true,
            exclusive: false,
            autoDelete: false);

        // Queue를 Exchange에 바인딩
        _channel.QueueBind(
            queue: "order-processing",
            exchange: "orders",
            routingKey: "order.created");

        // Prefetch 설정 (동시 처리 메시지 수 제한)
        _channel.BasicQos(0, 10, false);
    }

    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var consumer = new EventingBasicConsumer(_channel);
        
        consumer.Received += async (model, ea) =>
        {
            var body = ea.Body.ToArray();
            var message = Encoding.UTF8.GetString(body);

            try
            {
                _logger.LogInformation("메시지 수신: {MessageId}", 
                    ea.BasicProperties.MessageId);

                var orderMessage = JsonSerializer
                    .Deserialize<OrderCreatedMessage>(message);

                // 메시지 처리
                using var scope = _serviceProvider.CreateScope();
                var processor = scope.ServiceProvider
                    .GetRequiredService<IOrderProcessor>();
                
                await processor.ProcessOrderAsync(orderMessage);

                // 처리 완료 확인
                _channel.BasicAck(ea.DeliveryTag, false);
                
                _logger.LogInformation("메시지 처리 완료: {OrderId}", 
                    orderMessage.OrderId);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "메시지 처리 실패");

                // 재시도 또는 Dead Letter Queue로 이동
                _channel.BasicNack(ea.DeliveryTag, false, false);
            }
        };

        _channel.BasicConsume(
            queue: "order-processing",
            autoAck: false,
            consumer: consumer);

        return Task.CompletedTask;
    }

    public override void Dispose()
    {
        _channel?.Close();
        _connection?.Close();
        base.Dispose();
    }
}

// N+1 문제 해결
// ❌ 나쁜 예 - N+1 문제 발생
public async Task<List<OrderDto>> GetOrdersBad()
{
    var orders = await _context.Orders.ToListAsync();
    
    // 각 주문마다 별도 쿼리 실행 (N번)
    foreach (var order in orders)
    {
        order.User = await _context.Users
            .FirstOrDefaultAsync(u => u.Id == order.UserId);
        order.Items = await _context.OrderItems
            .Where(i => i.OrderId == order.Id)
            .ToListAsync();
    }
    
    return orders.Select(MapToDto).ToList();
}

// ✅ 좋은 예 - Eager Loading
public async Task<List<OrderDto>> GetOrdersGood()
{
    var orders = await _context.Orders
        .Include(o => o.User)
        .Include(o => o.Items)
            .ThenInclude(i => i.Product)
        .AsNoTracking()
        .ToListAsync();
    
    return orders.Select(MapToDto).ToList();
}

// ✅ 더 좋은 예 - Projection으로 필요한 데이터만
public async Task<List<OrderDto>> GetOrdersBest()
{
    return await _context.Orders
        .Select(o => new OrderDto
        {
            Id = o.Id,
            OrderDate = o.CreatedAt,
            UserName = o.User.Name,
            UserEmail = o.User.Email,
            TotalAmount = o.TotalAmount,
            Items = o.Items.Select(i => new OrderItemDto
            {
                ProductName = i.Product.Name,
                Quantity = i.Quantity,
                Price = i.Price
            }).ToList()
        })
        .AsNoTracking()
        .ToListAsync();
}

// 비동기 프로그래밍 최적화
// ❌ 나쁜 예 - 순차 실행
public async Task<DashboardData> GetDashboardDataBad()
{
    var orders = await _orderService.GetRecentOrdersAsync();
    var products = await _productService.GetPopularProductsAsync();
    var users = await _userService.GetActiveUsersAsync();
    var stats = await _statsService.GetStatisticsAsync();

    return new DashboardData
    {
        Orders = orders,
        Products = products,
        Users = users,
        Statistics = stats
    };
}

// ✅ 좋은 예 - 병렬 실행
public async Task<DashboardData> GetDashboardDataGood()
{
    var ordersTask = _orderService.GetRecentOrdersAsync();
    var productsTask = _productService.GetPopularProductsAsync();
    var usersTask = _userService.GetActiveUsersAsync();
    var statsTask = _statsService.GetStatisticsAsync();

    await Task.WhenAll(ordersTask, productsTask, usersTask, statsTask);

    return new DashboardData
    {
        Orders = await ordersTask,
        Products = await productsTask,
        Users = await usersTask,
        Statistics = await statsTask
    };
}

// Response Compression
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Response Compression 추가
        services.AddResponseCompression(options =>
        {
            options.EnableForHttps = true;
            options.Providers.Add<BrotliCompressionProvider>();
            options.Providers.Add<GzipCompressionProvider>();
            options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(
                new[] { "application/json", "text/json" });
        });

        services.Configure<BrotliCompressionProviderOptions>(options =>
        {
            options.Level = CompressionLevel.Fastest;
        });

        services.Configure<GzipCompressionProviderOptions>(options =>
        {
            options.Level = CompressionLevel.Optimal;
        });
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseResponseCompression();
    }
}

// 솔루션 구조
ECommercePlatform/
├── src/
│   ├── ApiGateway/
│   │   ├── ApiGateway.csproj
│   │   ├── Program.cs
│   │   ├── appsettings.json
│   │   └── Middleware/
│   │
│   ├── Services/
│   │   ├── ProductService/
│   │   │   ├── ProductService.Api/
│   │   │   ├── ProductService.Application/
│   │   │   ├── ProductService.Domain/
│   │   │   └── ProductService.Infrastructure/
│   │   │
│   │   ├── OrderService/
│   │   │   ├── OrderService.Api/
│   │   │   ├── OrderService.Application/
│   │   │   ├── OrderService.Domain/
│   │   │   └── OrderService.Infrastructure/
│   │   │
│   │   ├── UserService/
│   │   └── PaymentService/
│   │
│   ├── BuildingBlocks/
│   │   ├── Common/
│   │   │   ├── Common.csproj
│   │   │   ├── Models/
│   │   │   ├── Exceptions/
│   │   │   └── Extensions/
│   │   │
│   │   ├── EventBus/
│   │   │   ├── EventBus.csproj
│   │   │   ├── Abstractions/
│   │   │   └── RabbitMQ/
│   │   │
│   │   └── Logging/
│   │
│   └── WebApps/
│       ├── WebMVC/
│       └── WebSPA/
│
├── tests/
│   ├── ProductService.Tests/
│   ├── OrderService.Tests/
│   └── IntegrationTests/
│
└── docker-compose.yml

// Clean Architecture 기반 Product Service 구조

// Domain Layer - 비즈니스 로직의 핵심
namespace ProductService.Domain.Entities
{
    public class Product : BaseEntity
    {
        public string Name { get; private set; }
        public string Description { get; private set; }
        public decimal Price { get; private set; }
        public int Stock { get; private set; }
        public Category Category { get; private set; }
        public List<ProductImage> Images { get; private set; }

        private Product() { } // EF Core용

        public Product(string name, decimal price, int stock)
        {
            if (string.IsNullOrWhiteSpace(name))
                throw new ArgumentException("상품명은 필수입니다.");
            
            if (price <= 0)
                throw new ArgumentException("가격은 0보다 커야 합니다.");

            Name = name;
            Price = price;
            Stock = stock;
            Images = new List<ProductImage>();
        }

        public void UpdatePrice(decimal newPrice)
        {
            if (newPrice <= 0)
                throw new ArgumentException("가격은 0보다 커야 합니다.");

            Price = newPrice;
            UpdatedAt = DateTime.UtcNow;
        }

        public void DecreaseStock(int quantity)
        {
            if (quantity > Stock)
                throw new InvalidOperationException("재고가 부족합니다.");

            Stock -= quantity;
            UpdatedAt = DateTime.UtcNow;
        }

        public void IncreaseStock(int quantity)
        {
            Stock += quantity;
            UpdatedAt = DateTime.UtcNow;
        }
    }
}

// Application Layer - 유스케이스
namespace ProductService.Application.Commands
{
    public class CreateProductCommand : IRequest<int>
    {
        public string Name { get; set; }
        public string Description { get; set; }
        public decimal Price { get; set; }
        public int Stock { get; set; }
        public int CategoryId { get; set; }
    }

    public class CreateProductCommandHandler 
        : IRequestHandler<CreateProductCommand, int>
    {
        private readonly IProductRepository _repository;
        private readonly IEventBus _eventBus;
        private readonly ILogger<CreateProductCommandHandler> _logger;

        public CreateProductCommandHandler(
            IProductRepository repository,
            IEventBus eventBus,
            ILogger<CreateProductCommandHandler> logger)
        {
            _repository = repository;
            _eventBus = eventBus;
            _logger = logger;
        }

        public async Task<int> Handle(
            CreateProductCommand request, 
            CancellationToken cancellationToken)
        {
            // 도메인 엔티티 생성
            var product = new Product(
                request.Name, 
                request.Price, 
                request.Stock);
            
            product.Description = request.Description;

            // 저장
            await _repository.AddAsync(product);
            await _repository.UnitOfWork.SaveChangesAsync(cancellationToken);

            _logger.LogInformation(
                "상품 생성됨: {ProductId} - {ProductName}", 
                product.Id, product.Name);

            // 이벤트 발행
            await _eventBus.PublishAsync(new ProductCreatedEvent
            {
                ProductId = product.Id,
                Name = product.Name,
                Price = product.Price
            });

            return product.Id;
        }
    }
}

// Infrastructure Layer - 데이터 접근
namespace ProductService.Infrastructure.Repositories
{
    public class ProductRepository : IProductRepository
    {
        private readonly ProductDbContext _context;

        public IUnitOfWork UnitOfWork => _context;

        public ProductRepository(ProductDbContext context)
        {
            _context = context ?? throw new ArgumentNullException(nameof(context));
        }

        public async Task<Product> GetByIdAsync(int id)
        {
            return await _context.Products
                .Include(p => p.Category)
                .Include(p => p.Images)
                .FirstOrDefaultAsync(p => p.Id == id);
        }

        public async Task<IEnumerable<Product>> GetByCategoryAsync(int categoryId)
        {
            return await _context.Products
                .Where(p => p.Category.Id == categoryId)
                .Include(p => p.Images)
                .AsNoTracking()
                .ToListAsync();
        }

        public async Task<Product> AddAsync(Product product)
        {
            return (await _context.Products.AddAsync(product)).Entity;
        }

        public void Update(Product product)
        {
            _context.Entry(product).State = EntityState.Modified;
        }
    }
}

// API Layer - 컨트롤러
namespace ProductService.Api.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductsController : ControllerBase
    {
        private readonly IMediator _mediator;
        private readonly ILogger<ProductsController> _logger;

        public ProductsController(
            IMediator mediator,
            ILogger<ProductsController> logger)
        {
            _mediator = mediator;
            _logger = logger;
        }

        [HttpPost]
        [ProducesResponseType(StatusCodes.Status201Created)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        public async Task<ActionResult<int>> CreateProduct(
            [FromBody] CreateProductCommand command)
        {
            var productId = await _mediator.Send(command);
            return CreatedAtAction(
                nameof(GetProduct), 
                new { id = productId }, 
                productId);
        }

        [HttpGet("{id}")]
        [ProducesResponseType(typeof(ProductDto), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<ActionResult<ProductDto>> GetProduct(int id)
        {
            var query = new GetProductQuery { Id = id };
            var product = await _mediator.Send(query);

            if (product == null)
                return NotFound();

            return Ok(product);
        }

        [HttpPut("{id}/stock")]
        public async Task<IActionResult> UpdateStock(
            int id, 
            [FromBody] UpdateStockCommand command)
        {
            command.ProductId = id;
            await _mediator.Send(command);
            return NoContent();
        }
    }
}

# GitHub Actions를 사용한 CI/CD 파이프라인
# .github/workflows/deploy.yml

name: Build and Deploy

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

env:
  DOTNET_VERSION: '8.0.x'
  AZURE_WEBAPP_NAME: 'my-ecommerce-app'

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup .NET
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}
    
    - name: Restore dependencies
      run: dotnet restore
    
    - name: Build
      run: dotnet build --configuration Release --no-restore
    
    - name: Run unit tests
      run: dotnet test --no-build --verbosity normal --collect:"XPlat Code Coverage"
    
    - name: Upload coverage reports
      uses: codecov/codecov-action@v3
      with:
        files: ./coverage.cobertura.xml
    
    - name: Publish
      run: dotnet publish -c Release -o ./publish
    
    - name: Upload artifact
      uses: actions/upload-artifact@v3
      with:
        name: webapp
        path: ./publish

  docker-build:
    runs-on: ubuntu-latest
    needs: build-and-test
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v2
    
    - name: Login to Container Registry
      uses: docker/login-action@v2
      with:
        registry: ${{ secrets.ACR_LOGIN_SERVER }}
        username: ${{ secrets.ACR_USERNAME }}
        password: ${{ secrets.ACR_PASSWORD }}
    
    - name: Build and push Docker image
      uses: docker/build-push-action@v4
      with:
        context: .
        push: true
        tags: |
          ${{ secrets.ACR_LOGIN_SERVER }}/product-service:${{ github.sha }}
          ${{ secrets.ACR_LOGIN_SERVER }}/product-service:latest
        cache-from: type=registry,ref=${{ secrets.ACR_LOGIN_SERVER }}/product-service:buildcache
        cache-to: type=registry,ref=${{ secrets.ACR_LOGIN_SERVER }}/product-service:buildcache,mode=max

  deploy-to-staging:
    runs-on: ubuntu-latest
    needs: docker-build
    if: github.ref == 'refs/heads/develop'
    environment: staging
    
    steps:
    - name: Deploy to Azure Kubernetes Service (Staging)
      uses: azure/k8s-deploy@v4
      with:
        manifests: |
          k8s/staging/deployment.yml
          k8s/staging/service.yml
        images: |
          ${{ secrets.ACR_LOGIN_SERVER }}/product-service:${{ github.sha }}
        namespace: staging

  deploy-to-production:
    runs-on: ubuntu-latest
    needs: docker-build
    if: github.ref == 'refs/heads/main'
    environment: production
    
    steps:
    - name: Deploy to Azure Kubernetes Service (Production)
      uses: azure/k8s-deploy@v4
      with:
        manifests: |
          k8s/production/deployment.yml
          k8s/production/service.yml
        images: |
          ${{ secrets.ACR_LOGIN_SERVER }}/product-service:${{ github.sha }}
        namespace: production
        strategy: canary
        percentage: 20
    
    - name: Wait for canary validation
      run: sleep 300
    
    - name: Promote canary deployment
      uses: azure/k8s-deploy@v4
      with:
        manifests: |
          k8s/production/deployment.yml
        images: |
          ${{ secrets.ACR_LOGIN_SERVER }}/product-service:${{ github.sha }}
        namespace: production
        strategy: canary
        percentage: 100