AipGateway/Aip.Api.Service/Program.cs

using Aip.Api.Service;
using Aip.Api.Service.Aip.Serivces;
using Aip.Api.Service.Configurations;
using Aip.Api.Service.Services;
using Aip.Api.Service.Services.Interfaces;
using Aip.Api.Service.Middlewares;
using Microsoft.AspNetCore.HttpOverrides;
using Serilog;
using Serilog.Extensions.Logging;
using System.Net;
using Microsoft.OpenApi.Models;

internal class Program
{
    private static async Task Main(string[] args)
    {
        try
        {
            var configuration = new ConfigurationBuilder()
                 .SetBasePath(Directory.GetCurrentDirectory())
                 .AddJsonFile(
                     path: "appsettings.json",
                     optional: false,
                     reloadOnChange: true)
                 .AddJsonFile(
                     path: $"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json",
                     optional: true,
                     reloadOnChange: true)
                 .Build();

            var serillogLogger = new Serilog.LoggerConfiguration()
                .ReadFrom.Configuration(configuration)
                .MinimumLevel.Information()
                .Enrich.FromLogContext()
                .CreateLogger();

            Log.Logger = serillogLogger.ForContext<Program>();

            int licenseAccounts = LicenseManager.LocalValidateLicense();
            if (licenseAccounts <= 0)
            {
                if (licenseAccounts == 0)
                {
                    Log.Fatal("프로그램 라이센스에 허가된 계정 정보가 없습니다.");
                }
                else
                {
                    Log.Fatal("프로그램 라이센스 정보를 확인하지 못했습니다.");
                }
                return;
            }
            AipSettings? aipSettings = AipApiManager.LocalValidateLicense(configuration);
            if (aipSettings == null)
            {
                Log.Fatal("AIP API 라이센스 정보를 확인하지 못했습니다.");
                return;
            }

            var builder = WebApplication.CreateBuilder(args);
            builder.Logging.ClearProviders();
            builder.Host.UseSerilog((context, services, configuration) => configuration
                        .ReadFrom.Configuration(context.Configuration)
                        .ReadFrom.Services(services)
                        .Enrich.FromLogContext(), true);

            ConfigureSettings(builder.Host, builder.Environment); // 환경설정 파일 설정

            if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") != null)
            {
                Log.Information("Start Azure Information RESTFull API Service... License Accounts: {0} EA. [{1}]",
                    licenseAccounts, Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"));
            }
            else
            {
                Log.Information("Start Azure Information RESTFull API Service...License Accounts: {0} EA.", licenseAccounts);
            }

            Startup.SetSystemConfig();

            ILogger<ApiAuthService> apiAuthServiceLogger = new SerilogLoggerFactory(serillogLogger).CreateLogger<ApiAuthService>();
            ILogger<AipConfigService> apiConfigServiceLogger = new SerilogLoggerFactory(serillogLogger).CreateLogger<AipConfigService>();

            ApiAuthService apiAuthService = new ApiAuthService(apiAuthServiceLogger);
            apiAuthService.LoadAuthInformation();

            AipFileService aipFileService = new AipFileService(serillogLogger, aipSettings.GetConfig());
            AipConfigService aipConfigService = new AipConfigService(apiConfigServiceLogger, aipSettings, aipFileService);
            aipConfigService.DownloadAipFileInformations();


            builder.Services.AddSwaggerGen(c => {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "Azure Information Protection RESTFull API Service Gateway", Version = "v1" });
                //c.ResolveConflictingActions(apiDescriptions => apiDescriptions.First());
            });

            builder.Services.Configure<ForwardedHeadersOptions>(options =>
            {
                options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
                options.KnownNetworks.Clear();
                options.KnownProxies.Clear();
            });

            Log.Information("Start AIP RESTFull Service...Binding Port: {0}.", aipSettings.Port);

            //https://learn.microsoft.com/ko-kr/aspnet/core/fundamentals/servers/kestrel/options?view=aspnetcore-8.0
            builder.WebHost.ConfigureKestrel((context, serverOptions) =>
            {
                serverOptions.Limits.MaxRequestBodySize = 100_000_000;      // [RequestSizeLimit(100_000_000)] --> Controller 위에 선언,  IHttpMaxRequestBodySizeFeature
                serverOptions.Limits.MaxConcurrentConnections = 500;
                serverOptions.Limits.MaxConcurrentUpgradedConnections = 500;
                //serverOptions.Limits.Http2.InitialConnectionWindowSize = 131_072;
                serverOptions.AllowSynchronousIO = false;
                serverOptions.Listen(IPAddress.Any, aipSettings.Port, listenOptions =>
                {
                    //listenOptions.UseHttps("testCert.pfx", "testPassword");
                    //listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
                });
            });

            builder.Services.AddSingleton<AipSettings>(aipSettings);
            builder.Services.AddSingleton<IApiAuthService>(apiAuthService);
            builder.Services.AddSingleton<AipFileService>(aipFileService);
            builder.Services.AddSingleton<IApiConfigService>(aipConfigService);

            //builder.Services.AddSingleton<IAipDbLoggingService, AipDbLoggingService>();

            builder.Services.AddScoped<IApiAipService, ApiAipService>();
            builder.Services.AddScoped<IApiFileService, ApiFileService>();
            builder.Services.AddScoped<IApiStreamService, ApiStreamService>();

            builder.Services.AddControllers();

            builder.Services.AddCors(p => p.AddPolicy("corsapp", builder =>
            {
                //builder.WithOrigins("*", "http://localhost:3011", "https://localhost:3011", "https://localhost:7261").AllowAnyMethod().AllowAnyHeader();
            }));

            var app = builder.Build();

            app.UseSerilogRequestLogging();
            app.UseMiddleware<RequestResponseLogging>();

            app.UseRouting();
            app.UseCors(builder => builder
                .AllowAnyOrigin()
                .AllowAnyMethod()
                .AllowAnyHeader());
            app.UseCors("corsapp");

            app.UseAuthorization();

            //if (app.Environment.IsDevelopment())
            {
                app.UseSwagger();
                app.UseSwaggerUI(options =>
                {
                    options.SwaggerEndpoint("/swagger/v1/swagger.json", "AIP Gateway API v1");
                    options.RoutePrefix = "swagger-ui";
                });
            }

            app.MapControllers();

            app.Run();
            Log.Information("Azure Information RESTFull API Service...Stopped cleanly.");
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, "Azure Information RESTFull API Service...An unhandled exception occurred during bootstrapping.");
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }

    private static void ConfigureSettings(IHostBuilder hostBuilder, IHostEnvironment environment)
    {
        hostBuilder.ConfigureAppConfiguration(config =>
        {
            config
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile(
                    path: "appsettings.json",
                    optional: false,
                    reloadOnChange: true)
                .AddJsonFile(
                    path: $"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json",
                    optional: true,
                    reloadOnChange: true)
                .AddEnvironmentVariables();
        });
    }
}