public static void Main(string[] args) { var builder = WebApplication.CreateBuilder(args); // Additional configuration is required to successfully run gRPC on macOS. // For instructions on how to configure Kestrel and gRPC clients on macOS, visit https://go.microsoft.com/fwlink/?linkid=2099682 // Add services to the container. builder.Services.AddGrpc(); var app = builder.Build(); // Configure the HTTP request pipeline. app.MapGrpcService <GreeterService>(); app.MapGet("/", () => "Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909"); app.Run(); }
public async Task WebApplicationUrls_UpdatesIServerAddressesFeature() { var builder = WebApplication.CreateBuilder(); var urls = new List <string>(); var server = new MockAddressesServer(urls); builder.Services.AddSingleton <IServer>(server); await using var app = builder.Build(); app.Urls.Add("http://localhost:5002"); app.Urls.Add("https://localhost:5003"); await app.StartAsync(); Assert.Equal(2, urls.Count); Assert.Equal("http://localhost:5002", urls[0]); Assert.Equal("https://localhost:5003", urls[1]); }
public async static Task <int> Main(string[] args) { Log.Logger = new LoggerConfiguration() #if DEBUG .MinimumLevel.Debug() #else .MinimumLevel.Information() #endif .MinimumLevel.Override("Microsoft", LogEventLevel.Information) .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning) .Enrich.FromLogContext() .WriteTo.Async(c => c.File("Logs/logs.txt")) #if DEBUG .WriteTo.Async(c => c.Console()) #endif .CreateLogger(); try { Log.Information("Starting DataBasePerformanceLab.HttpApi.Host."); var builder = WebApplication.CreateBuilder(args); builder.Host.AddAppSettingsSecretsJson() .UseAutofac() .UseSerilog(); await builder.AddApplicationAsync <DataBasePerformanceLabHttpApiHostModule>(); var app = builder.Build(); AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true); await app.InitializeApplicationAsync(); await app.RunAsync(); return(0); } catch (Exception ex) { Log.Fatal(ex, "Host terminated unexpectedly!"); return(1); } finally { Log.CloseAndFlush(); } }
private static WebApplication BuildWebApplication( Tye.Hosting.Model.Application application, string[] args, ILogEventSink?sink) { var builder = WebApplication.CreateBuilder(args); // Logging for this application builder.Host.UseSerilog((context, configuration) => { configuration .MinimumLevel.Verbose() .Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore")) .Filter.ByExcluding(Matching.FromSource("Microsoft.Extensions")) .Filter.ByExcluding(Matching.FromSource("Microsoft.Hosting")) .Enrich .FromLogContext() .WriteTo .Console(); if (sink is object) { configuration.WriteTo.Sink(sink, LogEventLevel.Verbose); } }); builder.Services.AddRazorPages(o => o.RootDirectory = "/Dashboard/Pages"); builder.Services.AddServerSideBlazor(); builder.Services.AddOptions <StaticFileOptions>() .PostConfigure(o => { var fileProvider = new ManifestEmbeddedFileProvider(typeof(TyeHost).Assembly, "wwwroot"); // Make sure we don't remove the existing file providers (blazor needs this) o.FileProvider = new CompositeFileProvider(o.FileProvider, fileProvider); }); builder.Services.AddSingleton(application); var app = builder.Build(); return(app); }
public async Task WebApplicationBuilder_RegistersAuthenticationMiddlewares() { var builder = WebApplication.CreateBuilder(); builder.Authentication.AddJwtBearer(); await using var app = builder.Build(); var webAppAuthBuilder = Assert.IsType <WebApplicationAuthenticationBuilder>(builder.Authentication); Assert.True(webAppAuthBuilder.IsAuthenticationConfigured); // Authentication middleware isn't registered until application // is built on startup Assert.False(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); await app.StartAsync(); Assert.True(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); }
public async Task WebApplicationRunUrls_UpdatesIServerAddressesFeature() { var builder = WebApplication.CreateBuilder(); var urls = new List <string>(); var server = new MockAddressesServer(urls); builder.Services.AddSingleton <IServer>(server); await using var app = builder.Build(); var runTask = app.RunAsync("http://localhost:5001"); var url = Assert.Single(urls); Assert.Equal("http://localhost:5001", url); await app.StopAsync(); await runTask; }
protected override async Task BeforeExecutionAsync(IExecutionContext context) { var builder = WebApplication.CreateBuilder(); builder.Logging.ClearProviders(); builder.Services .AddRazorPages() .WithRazorPagesRoot("/Statiq.Helpers"); _app = builder.Build(); _app.MapRazorPages(); await _app.StartAsync(); _playwright = await Playwright.CreateAsync(); _browser = await _playwright.Chromium.LaunchAsync(); await base.BeforeExecutionAsync(context); }
public static void Main(string[] args) { var builder = WebApplication.CreateBuilder(new WebApplicationOptions { Args = args, ContentRootPath = Directory.GetCurrentDirectory(), // etc. }); // ## Dependency Injection stuff // ----------------------------------------------------------- var container = new Container(rules => // optional: Enables property injection for Controllers rules.With(propertiesAndFields: request => request.ServiceType.Name.EndsWith("Controller") ? PropertiesAndFields.Properties()(request) : null)); container.RegisterMyBusinessLogic(); // Here it goes the integration with the existing DryIoc container var diFactory = new DryIocServiceProviderFactory(container, ExampleOfCustomRegisterDescriptor); builder.Host.UseServiceProviderFactory(diFactory); builder.Services .AddMvc(options => options.EnableEndpointRouting = false) .AddControllersAsServices(); // other things... builder.Logging.ClearProviders(); builder.Logging.AddConsole(); //----------------------------------------------------------- var app = builder.Build(); app.UseMvc(); app.UseHttpsRedirection(); app.UseAuthorization(); app.Run(); }
public static void ConfigureEndpointDefaultsConfigureHttpsDefaults(string[] args) { // <snippet_ConfigureEndpointDefaultsConfigureHttpsDefaults> var builder = WebApplication.CreateBuilder(args); builder.WebHost.ConfigureKestrel((context, serverOptions) => { serverOptions.ConfigureEndpointDefaults(listenOptions => { // ... }); serverOptions.ConfigureHttpsDefaults(listenOptions => { // ... }); }); // </snippet_ConfigureEndpointDefaultsConfigureHttpsDefaults> }
public async Task PathBaseWorksWithoutUseRoutingWithWebApplication() { var builder = WebApplication.CreateBuilder(); builder.WebHost.UseTestServer(); await using var app = builder.Build(); app.UsePathBase("/base"); app.MapGet("/path", context => context.Response.WriteAsync("Response")); await app.StartAsync(); using var server = app.GetTestServer(); var response = await server.CreateClient().GetStringAsync("/base/path"); Assert.Equal("Response", response); }
public async static Task <int> Main(string[] args) { Log.Logger = new LoggerConfiguration() #if DEBUG .MinimumLevel.Debug() #else .MinimumLevel.Information() #endif .MinimumLevel.Override("Microsoft", LogEventLevel.Information) .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning) .Enrich.FromLogContext() .WriteTo.Async(c => c.File("Logs/logs.txt")) #if DEBUG .WriteTo.Async(c => c.Console()) #endif .CreateLogger(); try { Log.Information("Starting MyCompanyName.MyProjectName.IdentityServer."); var builder = WebApplication.CreateBuilder(args); builder.Host.AddAppSettingsSecretsJson() .UseAutofac() .UseSerilog(); await builder.AddApplicationAsync <MyProjectNameIdentityServerModule>(); var app = builder.Build(); await app.InitializeApplicationAsync(); await app.RunAsync(); return(0); } catch (Exception ex) { Log.Fatal(ex, "MyCompanyName.MyProjectName.IdentityServer terminated unexpectedly!"); return(1); } finally { Log.CloseAndFlush(); } }
public async Task WebApplicationBuilder_CanRegisterAuthzMiddlewareWithScopedService() { var builder = WebApplication.CreateBuilder(new WebApplicationOptions() { EnvironmentName = Environments.Development }); builder.Services.AddAuthorization(); builder.Services.AddScoped <IAuthorizationHandler, TestAuthorizationHandler>(); using var app = builder.Build(); Assert.False(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); Assert.False(app.Properties.ContainsKey("__AuthorizationMiddlewareSet")); await app.StartAsync(); Assert.False(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); Assert.True(app.Properties.ContainsKey("__AuthorizationMiddlewareSet")); }
static async Task Main(string[] args) { var builder = WebApplication.CreateBuilder(args); var jwtSettings = JwtSettings.FromConfiguration(builder.Configuration); builder.Services.AddIdentityCore <TodoUser>() .AddEntityFrameworkStores <TodoDbContext>(); builder.Services.AddDbContext <TodoDbContext>(options => options.UseInMemoryDatabase("Todos")); builder.Services.AddAuthorization(options => { options.AddPolicy("admin", policy => policy.RequireClaim("can_delete", "true")); options.AddPolicy("user", policy => policy.RequireClaim("can_view", "true")); }); builder.Services .AddAuthentication(JwtBearerDefaults.AuthenticationScheme) .AddJwtBearer(options => options.TokenValidationParameters = jwtSettings.TokenValidationParameters); var app = builder.Build(); using (var scope = app.Services.CreateScope()) { var userManager = scope.ServiceProvider.GetService <UserManager <TodoUser> >(); await userManager.CreateAsync(new TodoUser { UserName = "******", IsAdmin = true }, "Pass123456!"); } app.UseAuthentication(); app.UseAuthorization(); var auth = new AuthApi(jwtSettings); auth.MapRoutes(app); var todo = new TodoApi(); todo.MapRoutes(app); await app.RunAsync(); }
private static WebApplication BuildApplication(string[] args) { var builder = WebApplication.CreateBuilder(args); builder.Logging.AddFileLog(); builder.Services.ConfigureResource <DefaultResourceManager>(); builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IConfigureOptions <MvcRazorRuntimeCompilationOptions>, CompilationOptionsSetup>()); Type mvcBuilderType = typeof(Builder); PluginActivtor.LoadedPlugins.Add(new PluginDescriptor { Assembly = mvcBuilderType.Assembly, PluginType = mvcBuilderType }); builder.Services.UseZKEACMS(builder.Configuration, builder.Environment); var app = builder.Build(); return(app); }
public void WebApplicationBuilder_CanChangeSetWebRootPathsViaConfigureAppConfiguration() { var builder = WebApplication.CreateBuilder(); var webRootPath = "www"; var fullWebRootPath = Path.Combine(Directory.GetCurrentDirectory(), webRootPath); builder.WebHost.ConfigureAppConfiguration(builder => { builder.AddInMemoryCollection(new Dictionary <string, string> { { WebHostDefaults.WebRootKey, webRootPath } }); }); Assert.Equal(webRootPath, builder.WebHost.GetSetting("webroot")); var app = builder.Build(); Assert.Equal(fullWebRootPath, app.Environment.WebRootPath); }
public void WebApplicationBuilder_CanClearDefaultLoggers() { var listener = new TestEventListener(); var builder = WebApplication.CreateBuilder(); builder.Logging.ClearProviders(); var app = builder.Build(); var logger = app.Services.GetRequiredService <ILogger <WebApplicationTests> >(); var guid = Guid.NewGuid().ToString(); logger.LogInformation(guid); var events = listener.EventData.ToArray(); Assert.DoesNotContain(events, args => args.EventSource.Name == "Microsoft-Extensions-Logging" && args.Payload.OfType <string>().Any(p => p.Contains(guid))); }
public static async Task Main(string[] args) { var builder = WebApplication.CreateBuilder(args); builder.WebHost .ConfigureKestrel((context, options) => { options.Listen(IPAddress.Any, 5001, listenOptions => { // Use HTTP/3 listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3; listenOptions.UseHttps(); }); }); #endregion await using var app = builder.Build(); app.MapGet("/", () => "Hello World!"); await app.RunAsync(); }
public void WebApplicationBuilder_CanSetWebRootPaths(bool useSetter) { var builder = WebApplication.CreateBuilder(); var webRootPath = "www"; var fullWebRootPath = Path.Combine(Directory.GetCurrentDirectory(), webRootPath); if (useSetter) { builder.Environment.WebRootPath = webRootPath; } else { builder.WebHost.UseWebRoot(webRootPath); Assert.Equal(webRootPath, builder.WebHost.GetSetting("webroot")); } var app = builder.Build(); Assert.Equal(fullWebRootPath, app.Environment.WebRootPath); }
internal static async Task Main(string[] args) { var logger = LogManager.Setup().LoadConfigurationFromAppSettings().GetCurrentClassLogger(); logger.Debug($"init {nameof(Program.Main)}"); try { var webApiAssembly = System.Reflection.Assembly.GetExecutingAssembly(); var serviceInfo = Shared.WebApi.ServiceInfo.CreateInstance(webApiAssembly); //Configuration,ServiceCollection,Logging,WebHost(Kestrel) var app = WebApplication .CreateBuilder(args) .ConfigureAdncDefault(serviceInfo) .Build(); //Middlewares app.UseAdncDefault(endpointRoute: endpoint => { endpoint.MapGrpcService <Grpc.AuthGrpcServer>(); endpoint.MapGrpcService <Grpc.UsrGrpcServer>(); }); //Start await app .ChangeThreadPoolSettings() .UseRegistrationCenter() .RunAsync(); } catch (Exception ex) { logger.Error(ex, "Stopped program because of exception"); throw; } finally { // Ensure to flush and stop internal timers/threads before application-exit (Avoid segmentation fault on Linux) LogManager.Shutdown(); } }
public static void Main(string[] args) { var builder = WebApplication.CreateBuilder(args); if (builder.Environment.IsDevelopment() == false) { var secretClient = new SecretClient(new Uri(builder.Configuration["KeyVaultUri"]), new DefaultAzureCredential()); builder.Configuration.AddAzureKeyVault(secretClient, new KeyVaultSecretManager()); } // Add services to the container. builder.Services.Configure <BlobSettings>(builder.Configuration.GetSection(nameof(BlobSettings))); builder.Services.AddScoped <IBlobRepository, BlobRepository>(); builder.Services.AddControllers(); // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle builder.Services.AddEndpointsApiExplorer(); builder.Services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Title = "WebServiceUnsafe", Version = "v1" }); }); var app = builder.Build(); // Configure the HTTP request pipeline. app.UseSwagger(); app.UseSwaggerUI(c => c.DisplayRequestDuration()); app.UseHttpsRedirection(); app.UseAuthorization(); app.MapControllers(); app.Run(); }
public static void ServerCertificateSelector(string[] args) { // <snippet_ServerCertificateSelector> var builder = WebApplication.CreateBuilder(args); builder.WebHost.ConfigureKestrel(serverOptions => { serverOptions.ListenAnyIP(5005, listenOptions => { listenOptions.UseHttps(httpsOptions => { var localhostCert = CertificateLoader.LoadFromStoreCert( "localhost", "My", StoreLocation.CurrentUser, allowInvalid: true); var exampleCert = CertificateLoader.LoadFromStoreCert( "example.com", "My", StoreLocation.CurrentUser, allowInvalid: true); var subExampleCert = CertificateLoader.LoadFromStoreCert( "sub.example.com", "My", StoreLocation.CurrentUser, allowInvalid: true); var certs = new Dictionary <string, X509Certificate2>( StringComparer.OrdinalIgnoreCase) { ["localhost"] = localhostCert, ["example.com"] = exampleCert, ["sub.example.com"] = subExampleCert }; httpsOptions.ServerCertificateSelector = (connectionContext, name) => { if (name is not null && certs.TryGetValue(name, out var cert)) { return(cert); } return(exampleCert); }; }); }); });
static async Task Main(string[] args) { var builder = WebApplication.CreateBuilder(args); builder.Services.AddDbContext <TodoDbContext>(); builder.Services.AddCors(options => { options.AddDefaultPolicy( cb => { cb.AllowAnyOrigin(); cb.AllowAnyMethod(); } ); }); var app = builder.Build(); app.UseCors(); var todos = new TodoApi(); todos.MapRoutes(app); await app.RunAsync(); }
/// <summary> /// <para> /// This constructor starts the server using a Unix domain socket at the /// specified file system path. The server will run until disposed. /// </para> /// <note> /// This service is currently exposed as HTTP, not HTTPS. /// </note> /// </summary> /// <param name="socketPath"> /// Optionally overrides the path to the Unix domain socket path. This defaults to /// <see cref="KubeHelper.WinDesktopServiceSocketPath"/> where <b>neon-desktop</b> /// and <b>neon-cli</b> expect it to be. /// </param> /// <exception cref="GrpcServiceException">Thrown when the service could not be started.</exception> public DesktopService(string socketPath = null) { this.socketPath = socketPath ??= KubeHelper.WinDesktopServiceSocketPath; // Try to remove any existing socket file and if that fails we're // going to assume that another service is already running on the // socket. try { if (File.Exists(socketPath)) { File.Delete(socketPath); } } catch (Exception e) { throw new GrpcServiceException($"Cannot start service using Unix socket at: {socketPath}", e); } var builder = WebApplication.CreateBuilder(); builder.Services.AddCodeFirstGrpc(); builder.WebHost.UseUrls(); builder.WebHost.UseKestrel( options => { options.ListenUnixSocket(socketPath, configure => configure.Protocols = HttpProtocols.Http2); }); var app = builder.Build(); app.UseRouting(); app.UseEndpoints(endpoints => endpoints.MapGrpcService <GrpcDesktopService>()); cts = new CancellationTokenSource(); task = app.StartAsync(cts.Token); }
public async Task WebApplicationBuilder_StartupFilterCanAddTerminalMiddleware() { var builder = WebApplication.CreateBuilder(); builder.WebHost.UseTestServer(); builder.Services.AddSingleton <IStartupFilter, TerminalMiddlewareStartupFilter>(); await using var app = builder.Build(); app.MapGet("/defined", () => { }); await app.StartAsync(); var client = app.GetTestClient(); var definedResult = await client.GetAsync("http://localhost/defined"); definedResult.EnsureSuccessStatusCode(); var terminalResult = await client.GetAsync("http://localhost/undefined"); Assert.Equal(418, (int)terminalResult.StatusCode); }
public static void Main(string[] args) { var builder = WebApplication.CreateBuilder(args); // Additional configuration is required to successfully run gRPC on macOS. // For instructions on how to configure Kestrel and gRPC clients on macOS, visit https://go.microsoft.com/fwlink/?linkid=2099682 // Add services to the container. builder.Services.AddGrpc(); builder.Services.AddGrpcReflection(); builder.Configuration.SetBasePath("/etc/ispindel/jobrunner") .AddJsonFile("appsettings.json", optional: false) .AddJsonFile($"appsettings.Production.json", optional: false); builder.Services.Configure <MqttOptions>(builder.Configuration.GetSection(MqttOptions.MqttPosition)); builder.Services.Configure <SpindelServerOptions>(builder.Configuration.GetSection(SpindelServerOptions.SpindelServerPosition)); builder.Services.Configure <DbOptions>(builder.Configuration.GetSection(DbOptions.DbPosition)); builder.Services.Configure <GrpcServerOptions>(builder.Configuration.GetSection(GrpcServerOptions.GrpcServerPosition)); builder.Services.AddSingleton <IMqttClientFactory, MqttClientFactory>(); builder.Services.AddDbContextFactory <iSpindelContext>(options => { options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")); }); //builder.Services.AddSingleton<IDbContextFactory, DbContextFactory>(); builder.Services.AddSingleton <ISpindelService, iSpindelServer>(); var app = builder.Build(); // Configure the HTTP request pipeline. app.MapGrpcService <Services.RecordingService>(); if (builder.Environment.IsDevelopment()) { app.MapGrpcReflectionService(); } app.MapGet("/", () => "Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909"); app.Run(); }
static async Task Main(string[] args) { var builder = WebApplication.CreateBuilder(args); builder.Configuration.AddYamlFile("appsettings.yml", optional: true); builder.Host.UseSerilog((context, configuration) => configuration .Enrich .FromLogContext() .WriteTo .Console() ); builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory()); builder.Host.ConfigureContainer <ContainerBuilder>(b => { // Register services using Autofac specific methods here }); var app = builder.Build(); app.Listen("http://localhost:3000"); if (app.Environment.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseRouting(); app.MapGet("/", async context => { await context.Response.WriteAsync("Hello World"); }); await app.RunAsync(); }
public async Task WebApplication_CanCallUseRoutingWithouUseEndpoints() { var builder = WebApplication.CreateBuilder(); builder.WebHost.UseTestServer(); await using var app = builder.Build(); app.MapGet("/new", () => "new"); // Rewrite "/old" to "/new" before matching routes app.Use((context, next) => { if (context.Request.Path == "/old") { context.Request.Path = "/new"; } return(next(context)); }); app.UseRouting(); await app.StartAsync(); var endpointDataSource = app.Services.GetRequiredService <EndpointDataSource>(); var newEndpoint = Assert.Single(endpointDataSource.Endpoints); var newRouteEndpoint = Assert.IsType <RouteEndpoint>(newEndpoint); Assert.Equal("/new", newRouteEndpoint.RoutePattern.RawText); var client = app.GetTestClient(); var oldResult = await client.GetAsync("http://localhost/old"); oldResult.EnsureSuccessStatusCode(); Assert.Equal("new", await oldResult.Content.ReadAsStringAsync()); }
private static void Start(string[] bindingUrls) { var(loggerProvider, logger) = CreateLoggers(); logger.LogInformation("Application starts"); var builder = WebApplication.CreateBuilder(); builder.Logging.ClearProviders(); builder.Logging.AddProvider(loggerProvider); SetupServices(builder.Services); if (bindingUrls?.Length > 0) { bindingUrls = bindingUrls.Where(x => !string.IsNullOrWhiteSpace(x)).ToArray(); logger.LogInformation($"Binding URLs: {string.Join(',', bindingUrls)}"); builder.WebHost.UseUrls(bindingUrls); builder.WebHost.ConfigureKestrel(app => { app.AllowSynchronousIO = true; }); } else { logger.LogWarning("No binding URLs were specified!"); } var app = builder.Build(); _ = app.Environment.IsDevelopment() ? app.UseUnhandledExceptionHandler() : app.UseDeveloperExceptionPage(); app.UseRequestLogger(); app.UseRequestPipeline(); app.Run(); }
public static void Main(string[] args) { // Load configs LoadConfigsAsync(); // Create builder var builder = WebApplication.CreateBuilder(args); builder.Host.ConfigureWebHostDefaults(webBuilder => { webBuilder.UseUrls("http://localhost:3000", "https://localhost:3001"); }); // Set up services ConfigureServices(builder); // Build web app var app = builder.Build(); // Configure application ConfigureApp(app); app.MapGet("/api/ping", () => "pong"); // Add API routes BaseAPI.AddRoutes(app); UploadAPI.AddRoutes(app); ChannelAPI.AddRoutes(app); CategoryAPI.AddRoutes(app); PlanetAPI.AddRoutes(app); UserAPI.AddRoutes(app); MemberAPI.AddRoutes(app); RoleAPI.AddRoutes(app); EmbedAPI.AddRoutes(app); // Run app.Run(); }
public async Task WebApplicationConfiguration_EnablesForwardedHeadersFromConfig() { var builder = WebApplication.CreateBuilder(); builder.WebHost.UseTestServer(); builder.Configuration["FORWARDEDHEADERS_ENABLED"] = "true"; await using var app = builder.Build(); app.Run(context => { Assert.Equal("https", context.Request.Scheme); return(Task.CompletedTask); }); await app.StartAsync(); var client = app.GetTestClient(); client.DefaultRequestHeaders.Add("x-forwarded-proto", "https"); var result = await client.GetAsync("http://localhost/"); result.EnsureSuccessStatusCode(); }