托管生命周期与部署

// 通用主机最小示例（Worker Service 模板本质）
var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddHostedService<Worker>();

var host = builder.Build();
await host.RunAsync();

// WebApplication 也是建立在 IHost 之上
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();

var app = builder.Build();
app.MapControllers();
await app.RunAsync();

// 访问底层 IHost 的能力
var lifetime = app.Services.GetRequiredService<IHostApplicationLifetime>();

public class DailyCleanupService : BackgroundService
{
    private readonly ILogger<DailyCleanupService> _logger;
    private readonly IServiceScopeFactory _scopeFactory;

    public DailyCleanupService(ILogger<DailyCleanupService> logger,
                               IServiceScopeFactory scopeFactory)
    {
        _logger = logger;
        _scopeFactory = scopeFactory;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("清理服务已启动");
        using var timer = new PeriodicTimer(TimeSpan.FromHours(24));

        while (await timer.WaitForNextTickAsync(stoppingToken))
        {
            // 每次创建作用域：注入 Scoped 服务
            using var scope = _scopeFactory.CreateScope();
            var repo = scope.ServiceProvider.GetRequiredService<IOrderRepository>();
            var deleted = await repo.CleanExpiredAsync(DateTime.UtcNow.AddDays(-90));
            _logger.LogInformation("清理过期订单 {Count} 条", deleted);
        }
    }
}

// 注册
builder.Services.AddHostedService<DailyCleanupService>();

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHostedService<CacheWarmer>();       // 先启动
builder.Services.AddHostedService<MessageConsumer>();    // 后启动

// 健康检查
builder.Services.AddHealthChecks()
    .AddDbContextCheck<ShopDbContext>()
    .AddCheck<ReadyCheck>("ready");

var app = builder.Build();
app.MapHealthChecks("/healthz");

var lifetime = app.Services.GetRequiredService<IHostApplicationLifetime>();
lifetime.ApplicationStarted.Register(() =>
{
    Console.WriteLine("所有服务启动完成，应用可服务流量");
});

// 就绪探针：依赖预热完成
public class ReadyCheck : IHealthCheck
{
    private readonly IOptionsMonitor<CacheWarmerState> _state;
    public ReadyCheck(IOptionsMonitor<CacheWarmerState> state) => _state = state;

    public Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context, CancellationToken ct) =>
        Task.FromResult(_state.CurrentValue.Warmed
            ? HealthCheckResult.Healthy()
            : HealthCheckResult.Unhealthy("缓存尚未预热完成"));
}

var builder = WebApplication.CreateBuilder(args);

// 默认 30 秒，按需调整
builder.Host.ConfigureHostOptions(o => o.ShutdownTimeout = TimeSpan.FromSeconds(20));

var app = builder.Build();
app.Lifetime.ApplicationStopping.Register(() =>
{
    Console.WriteLine("正在优雅关闭，等待在途请求完成...");
});

await app.RunAsync();

// Hosted Service 响应取消，主动收尾
public class MessageConsumer : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
            // 处理一批消息后检查取消
        }

        // 退出前刷新缓冲
        Console.WriteLine("消费服务已停止，剩余消息留待下次处理");
    }
}

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    // 显式端点（跳过 UseUrls 的环境变量）
    options.Listen(IPAddress.Any, 8080);

    // HTTPS 端点由反向代理终结时不需要
    // 直接终结 TLS 的场合：
    options.Listen(IPAddress.Any, 8443, listen =>
        listen.UseHttps("cert.pfx", "password"));

    // 请求体上限
    options.Limits.MaxRequestBodySize = 10 * 1024 * 1024;

    // 超时控制
    options.Limits.KeepAliveTimeout = TimeSpan.FromSeconds(120);
    options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(30);

    // 并发连接
    options.Limits.MaxConcurrentConnections = 10_000;
});

# 构建阶段
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY . .
RUN dotnet publish "src/Shop.Api/Shop.Api.csproj" -c Release -o /app/publish

# 运行阶段
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app
COPY --from=build /app/publish .
EXPOSE 8080
ENV ASPNETCORE_URLS=http://+:8080
ENTRYPOINT ["dotnet", "Shop.Api.dll"]

# docker-compose.yml 片段
services:
  api:
    build: .
    ports:
      - "8080:8080"
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
      - ConnectionStrings__Default=Server=db;Database=shop;...
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/healthz"]
      interval: 10s
      timeout: 5s
      retries: 3
    depends_on:
      db:
        condition: service_healthy

# 基础发布
dotnet publish -c Release -o out

# 单文件 + 裁剪（减小体积，牺牲 JIT 灵活性）
dotnet publish -c Release -r linux-x64 \
  --self-contained true /p:PublishSingleFile=true /p:PublishTrimmed=true

# 预览发布内容
ls out

# Linux systemd 单元（单机部署）
[Unit]
Description=Shop API
After=network.target

[Service]
WorkingDirectory=/opt/shop
ExecStart=/usr/bin/dotnet /opt/shop/Shop.Api.dll
Environment=ASPNETCORE_ENVIRONMENT=Production
Restart=always
RestartSec=10
User=www-data

[Install]
WantedBy=multi-user.target