// C# 코드에서 환경 변수 읽기
var connectionString = Configuration.GetConnectionString("DefaultConnection");
var apiKey = Configuration["MyApiKey"];

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

variables:
  buildConfiguration: 'Release'

steps:
- task: UseDotNet@2
  inputs:
    version: '6.x'
    
- task: DotNetCoreCLI@2
  displayName: 'Restore packages'
  inputs:
    command: 'restore'
    projects: '**/*.csproj'
    
- task: DotNetCoreCLI@2
  displayName: 'Build project'
  inputs:
    command: 'build'
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration)'
    
- task: DotNetCoreCLI@2
  displayName: 'Run tests'
  inputs:
    command: 'test'
    projects: '**/*Tests.csproj'
    
- task: DotNetCoreCLI@2
  displayName: 'Publish'
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    
- task: PublishBuildArtifacts@1
  displayName: 'Publish artifacts'
  inputs:
    PathtoPublish: '$(Build.ArtifactStagingDirectory)'
    ArtifactName: 'drop'

name: Deploy to Azure

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

env:
  AZURE_WEBAPP_NAME: your-app-name
  DOTNET_VERSION: '6.0.x'

jobs:
  build-and-deploy:
    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: Test
      run: dotnet test --no-build --verbosity normal
    
    - name: Publish
      run: dotnet publish -c Release -o ${{env.DOTNET_ROOT}}/myapp
    
    - name: Deploy to Azure Web App
      uses: azure/webapps-deploy@v2
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: ${{env.DOTNET_ROOT}}/myapp

dotnet add package Microsoft.ApplicationInsights.AspNetCore

builder.Services.AddApplicationInsightsTelemetry();

{
  "ApplicationInsights": {
    "ConnectionString": "InstrumentationKey=your-key-here"
  }
}

public class HomeController : Controller
{
    private readonly TelemetryClient _telemetry;
    
    public HomeController(TelemetryClient telemetry)
    {
        _telemetry = telemetry;
    }
    
    public IActionResult Purchase(int productId)
    {
        // 구매 이벤트 추적
        _telemetry.TrackEvent("ProductPurchased", 
            new Dictionary<string, string>
            {
                { "ProductId", productId.ToString() },
                { "UserId", User.Identity.Name }
            });
        
        // 비즈니스 로직...
        
        return View();
    }
}

az webapp log tail --name your-app-name --resource-group your-resource-group

public class HomeController : Controller
{
    private readonly ILogger<HomeController> _logger;
    
    public HomeController(ILogger<HomeController> logger)
    {
        _logger = logger;
    }
    
    public IActionResult Index()
    {
        _logger.LogInformation("Home page visited");
        
        try
        {
            // 비즈니스 로직...
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An error occurred in Index action");
            throw;
        }
        
        return View();
    }
}

dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools

using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
    
    public DbSet<Product> Products { get; set; }
    public DbSet<Order> Orders { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        
        // 모델 구성...
        modelBuilder.Entity<Product>()
            .HasKey(p => p.Id);
            
        modelBuilder.Entity<Product>()
            .Property(p => p.Name)
            .IsRequired()
            .HasMaxLength(100);
    }
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
}

public class Order
{
    public int Id { get; set; }
    public DateTime OrderDate { get; set; }
    public int ProductId { get; set; }
    public Product Product { get; set; }
    public int Quantity { get; set; }
}

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=tcp:your-server.database.windows.net,1433;Initial Catalog=your-database;Persist Security Info=False;User ID=your-username;Password=your-password;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"
  }
}

builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("DefaultConnection")));

dotnet ef migrations add InitialCreate
dotnet ef database update

public class ProductsController : Controller
{
    private readonly ApplicationDbContext _context;
    
    public ProductsController(ApplicationDbContext context)
    {
        _context = context;
    }
    
    public async Task<IActionResult> Index()
    {
        var products = await _context.Products
            .OrderBy(p => p.Name)
            .ToListAsync();
            
        return View(products);
    }
    
    [HttpPost]
    public async Task<IActionResult> Create(Product product)
    {
        if (ModelState.IsValid)
        {
            _context.Products.Add(product);
            await _context.SaveChangesAsync();
            
            return RedirectToAction(nameof(Index));
        }
        
        return View(product);
    }
    
    public async Task<IActionResult> Delete(int id)
    {
        var product = await _context.Products.FindAsync(id);
        
        if (product != null)
        {
            _context.Products.Remove(product);
            await _context.SaveChangesAsync();
        }
        
        return RedirectToAction(nameof(Index));
    }
}

dotnet add package Azure.Identity
dotnet add package Azure.Security.KeyVault.Secrets

using Azure.Identity;
using Azure.Security.KeyVault.Secrets;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Key Vault 클라이언트 생성
        var keyVaultUrl = "https://your-keyvault.vault.azure.net/";
        var client = new SecretClient(
            new Uri(keyVaultUrl), 
            new DefaultAzureCredential());
        
        // 비밀 가져오기
        var secret = client.GetSecret("DatabasePassword");
        var password = secret.Value.Value;
        
        // 연결 문자열 구성
        var connectionString = $"Server=...;Password={password};...";
        
        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(connectionString));
    }
}

dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore

public class ApplicationDbContext : IdentityDbContext<IdentityUser>
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
    
    // DbSet들...
}

builder.Services.AddDefaultIdentity<IdentityUser>(options => 
{
    // 비밀번호 정책
    options.Password.RequireDigit = true;
    options.Password.RequireLowercase = true;
    options.Password.RequireUppercase = true;
    options.Password.RequireNonAlphanumeric = true;
    options.Password.RequiredLength = 8;
    
    // 계정 잠금 정책
    options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(15);
    options.Lockout.MaxFailedAccessAttempts = 5;
})
.AddEntityFrameworkStores<ApplicationDbContext>();

builder.Services.AddAuthentication()
    .AddGoogle(options =>
    {
        options.ClientId = Configuration["Google:ClientId"];
        options.ClientSecret = Configuration["Google:ClientSecret"];
    })
    .AddMicrosoftAccount(options =>
    {
        options.ClientId = Configuration["Microsoft:ClientId"];
        options.ClientSecret = Configuration["Microsoft:ClientSecret"];
    });

[Authorize]
public class AdminController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
}

public class ProductsController : Controller
{
    // 누구나 볼 수 있음
    public IActionResult Index()
    {
        return View();
    }
    
    // 인증된 사용자만 가능
    [Authorize]
    public IActionResult Create()
    {
        return View();
    }
    
    // Admin 역할만 가능
    [Authorize(Roles = "Admin")]
    public IActionResult Delete(int id)
    {
        // 삭제 로직...
        return RedirectToAction(nameof(Index));
    }
}

public class RoleInitializer
{
    public static async Task InitializeAsync(
        UserManager<IdentityUser> userManager,
        RoleManager<IdentityRole> roleManager)
    {
        // 역할 생성
        string[] roleNames = { "Admin", "Manager", "User" };
        
        foreach (var roleName in roleNames)
        {
            if (!await roleManager.RoleExistsAsync(roleName))
            {
                await roleManager.CreateAsync(new IdentityRole(roleName));
            }
        }
        
        // 관리자 계정 생성
        var adminEmail = "admin@example.com";
        var adminUser = await userManager.FindByEmailAsync(adminEmail);
        
        if (adminUser == null)
        {
            adminUser = new IdentityUser
            {
                UserName = adminEmail,
                Email = adminEmail,
                EmailConfirmed = true
            };
            
            await userManager.CreateAsync(adminUser, "Admin@123");
            await userManager.AddToRoleAsync(adminUser, "Admin");
        }
    }
}

// Program.cs
var app = builder.Build();

// HTTPS 리디렉션
app.UseHttpsRedirection();

// HSTS (HTTP Strict Transport Security)
app.UseHsts();

// 보안 헤더 추가
app.Use(async (context, next) =>
{
    context.Response.Headers.Add("X-Content-Type-Options", "nosniff");
    context.Response.Headers.Add("X-Frame-Options", "DENY");
    context.Response.Headers.Add("X-XSS-Protection", "1; mode=block");
    context.Response.Headers.Add("Referrer-Policy", "no-referrer");
    
    await next();
});

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

// Azure CLI로 슬롯 스왑
az webapp deployment slot swap \
    --name your-app-name \
    --resource-group your-resource-group \
    --slot staging \
    --target-slot production

public class HomeController : Controller
{
    private readonly IFeatureManager _featureManager;
    
    public async Task<IActionResult> Index()
    {
        // Feature Flag로 A/B 테스트
        var useNewDesign = await _featureManager.IsEnabledAsync("NewDesign");
        
        if (useNewDesign)
        {
            return View("IndexNew");
        }
        else
        {
            return View("IndexOld");
        }
    }
}

public class ProductService
{
    private readonly ApplicationDbContext _context;
    private readonly IMemoryCache _cache;
    private readonly ILogger<ProductService> _logger;
    
    public async Task<Product> GetProductAsync(int id)
    {
        var cacheKey = $"product_{id}";
        
        // 캐시에서 먼저 확인
        if (_cache.TryGetValue(cacheKey, out Product product))
        {
            _logger.LogInformation($"Product {id} retrieved from cache");
            return product;
        }
        
        // 캐시에 없으면 DB에서 조회
        product = await _context.Products.FindAsync(id);
        
        if (product != null)
        {
            // 캐시에 저장 (10분간 유지)
            var cacheOptions = new MemoryCacheEntryOptions()
                .SetAbsoluteExpiration(TimeSpan.FromMinutes(10))
                .SetSlidingExpiration(TimeSpan.FromMinutes(2));
                
            _cache.Set(cacheKey, product, cacheOptions);
            _logger.LogInformation($"Product {id} cached");
        }
        
        return product;
    }
}

// Program.cs
builder.Services.AddResponseCompression(options =>
{
    options.EnableForHttps = true;
    options.Providers.Add<BrotliCompressionProvider>();
    options.Providers.Add<GzipCompressionProvider>();
});

var app = builder.Build();
app.UseResponseCompression();

MyShopAPI/
├── Controllers/
│   ├── ProductsController.cs
│   ├── OrdersController.cs
│   └── UsersController.cs
├── Models/
│   ├── Product.cs
│   ├── Order.cs
│   └── User.cs
├── Data/
│   └── ApplicationDbContext.cs
├── Services/
│   ├── IProductService.cs
│   ├── ProductService.cs
│   ├── IOrderService.cs
│   └── OrderService.cs
├── DTOs/
│   ├── ProductDto.cs
│   └── OrderDto.cs
├── Program.cs
└── appsettings.json

public class Product
{
    public int Id { get; set; }
    
    [Required]
    [MaxLength(100)]
    public string Name { get; set; }
    
    [MaxLength(500)]
    public string Description { get; set; }
    
    [Range(0, double.MaxValue)]
    public decimal Price { get; set; }
    
    [Range(0, int.MaxValue)]
    public int Stock { get; set; }
    
    public string ImageUrl { get; set; }
    
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IProductService _productService;
    private readonly ILogger<ProductsController> _logger;
    
    public ProductsController(
        IProductService productService,
        ILogger<ProductsController> logger)
    {
        _productService = productService;
        _logger = logger;
    }
    
    [HttpGet]
    public async Task<ActionResult<IEnumerable<ProductDto>>> GetProducts(
        [FromQuery] int page = 1,
        [FromQuery] int pageSize = 10)
    {
        try
        {
            var products = await _productService.GetProductsAsync(page, pageSize);
            return Ok(products);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting products");
            return StatusCode(500, "Internal server error");
        }
    }
    
    [HttpGet("{id}")]
    public async Task<ActionResult<ProductDto>> GetProduct(int id)
    {
        var product = await _productService.GetProductByIdAsync(id);
        
        if (product == null)
        {
            return NotFound();
        }
        
        return Ok(product);
    }
    
    [HttpPost]
    [Authorize(Roles = "Admin")]
    public async Task<ActionResult<ProductDto>> CreateProduct(ProductDto productDto)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        
        var product = await _productService.CreateProductAsync(productDto);
        
        return CreatedAtAction(
            nameof(GetProduct),
            new { id = product.Id },
            product);
    }
    
    [HttpPut("{id}")]
    [Authorize(Roles = "Admin")]
    public async Task<IActionResult> UpdateProduct(int id, ProductDto productDto)
    {
        if (id != productDto.Id)
        {
            return BadRequest();
        }
        
        var updated = await _productService.UpdateProductAsync(productDto);
        
        if (!updated)
        {
            return NotFound();
        }
        
        return NoContent();
    }
    
    [HttpDelete("{id}")]
    [Authorize(Roles = "Admin")]
    public async Task<IActionResult> DeleteProduct(int id)
    {
        var deleted = await _productService.DeleteProductAsync(id);
        
        if (!deleted)
        {
            return NotFound();
        }
        
        return NoContent();
    }
}

public class ProductService : IProductService
{
    private readonly ApplicationDbContext _context;
    private readonly IMemoryCache _cache;
    private readonly ILogger<ProductService> _logger;
    
    public async Task<IEnumerable<ProductDto>> GetProductsAsync(int page, int pageSize)
    {
        var cacheKey = $"products_page_{page}_size_{pageSize}";
        
        if (_cache.TryGetValue(cacheKey, out IEnumerable<ProductDto> cachedProducts))
        {
            return cachedProducts;
        }
        
        var products = await _context.Products
            .OrderBy(p => p.Name)
            .Skip((page - 1) * pageSize)
            .Take(pageSize)
            .Select(p => new ProductDto
            {
                Id = p.Id,
                Name = p.Name,
                Description = p.Description,
                Price = p.Price,
                Stock = p.Stock,
                ImageUrl = p.ImageUrl
            })
            .ToListAsync();
        
        var cacheOptions = new MemoryCacheEntryOptions()
            .SetAbsoluteExpiration(TimeSpan.FromMinutes(5));
            
        _cache.Set(cacheKey, products, cacheOptions);
        
        return products;
    }
    
    public async Task<ProductDto> CreateProductAsync(ProductDto productDto)
    {
        var product = new Product
        {
            Name = productDto.Name,
            Description = productDto.Description,
            Price = productDto.Price,
            Stock = productDto.Stock,
            ImageUrl = productDto.ImageUrl,
            CreatedAt = DateTime.UtcNow,
            UpdatedAt = DateTime.UtcNow
        };
        
        _context.Products.Add(product);
        await _context.SaveChangesAsync();
        
        // 캐시 무효화
        _cache.Remove("products_page_1_size_10");
        
        productDto.Id = product.Id;
        return productDto;
    }
    
    // 나머지 메서드들...
}

# Azure CLI로 리소스 생성
az group create --name MyShopRG --location koreacentral

az sql server create \
    --name myshop-sql-server \
    --resource-group MyShopRG \
    --location koreacentral \
    --admin-user sqladmin \
    --admin-password YourPassword123!

az sql db create \
    --resource-group MyShopRG \
    --server myshop-sql-server \
    --name MyShopDB \
    --service-objective Basic

az appservice plan create \
    --name MyShopPlan \
    --resource-group MyShopRG \
    --sku B1

az webapp create \
    --name myshop-api \
    --resource-group MyShopRG \
    --plan MyShopPlan \
    --runtime "DOTNET|6.0"

az webapp config connection-string set \
    --name myshop-api \
    --resource-group MyShopRG \
    --connection-string-type SQLAzure \
    --settings DefaultConnection="Server=tcp:myshop-sql-server.database.windows.net,1433;Database=MyShopDB;User ID=sqladmin;Password=YourPassword123!;Encrypt=True;"