public static IWebHostBuilder UseOpenShiftIntegration(this IWebHostBuilder builder, Action <OpenShiftIntegrationOptions> configureOptions) { if (configureOptions == null) { throw new ArgumentNullException(nameof(configureOptions)); } if (PlatformEnvironment.IsOpenShift) { // Clear the urls. We'll explicitly configure Kestrel depending on the options. builder.UseUrls(new string[] { }); builder.ConfigureServices(services => { services.Configure(configureOptions); services.AddSingleton <OpenShiftCertificateLoader>(); services.AddSingleton <IConfigureOptions <KestrelServerOptions>, KestrelOptionsSetup>(); services.AddSingleton <IHostedService, OpenShiftCertificateExpiration>(); }); } else { builder.ConfigureKestrel(opt => { opt.ListenLocalhost(5023, o => o.Protocols = HttpProtocols.Http2); }); } return(builder); }
public void Configure(IWebHostBuilder builder) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } ClearStartupHookEnvironmentVariable(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { uint listenFd; try { var listenFdAsString = Environment.GetEnvironmentVariable("ZOCKET_LISTEN_FD"); listenFd = uint.Parse(listenFdAsString); builder.ConfigureKestrel(options => { options.ListenHandle(listenFd); }); } catch (FormatException) { return; } // We do this to prevent leaking a socket fcntl(Convert.ToInt32(listenFd), F_SETFD, FD_CLOEXEC); } }
/// <summary> /// 应用配置 /// </summary> /// <param name="webBuilder"></param> /// <param name="config"></param> public static void DeployConfig(IWebHostBuilder webBuilder, KestrelConfig config) { // 判断是否启用Kestrel服务 if (config.Enable) { webBuilder.ConfigureKestrel(options => { // 判断是否启用HTTP配置 if (config.HttpEnable) { // 填入配置中的监听端口 options.Listen(IPAddress.Any, config.HttpPort); } // 判断是否启用HTTPS配置 if (config.HttpsEnable) { // 填入配置中的监听端口 options.Listen(IPAddress.Any, config.HttpsPort, listenOptions => { // 填入配置中的pfx文件路径和指定的密码 listenOptions.UseHttps(config.HttpsPfxPath, config.HttpsPfxPwd); }); } }); } }
public static IWebHostBuilder ConfigureGrpcServer(this IWebHostBuilder webBuilder) { webBuilder.ConfigureServices(services => { services.AddGrpc(options => { options.Interceptors.Add <GlobalServerExceptionInterceptor>(); options.Interceptors.Add <GlobalServerLoggerInterceptor>(); }); services.AddSingleton <MessageOrchestrator>(); }); webBuilder.ConfigureKestrel((context, options) => { var grpcPort = context.Configuration.GetValue <int>("RpcServer:Port", -1); if (grpcPort <= 0) { throw new ConfigurationErrorsException("RpcServer.Port is missing"); } options.ListenLocalhost(grpcPort, o => o.Protocols = HttpProtocols.Http2); options.ListenLocalhost(grpcPort - 100, o => o.Protocols = HttpProtocols.Http1); }); return(webBuilder); }
public static void SplitHttpProtocolsIfDevelopment(this IWebHostBuilder webBuilder) { var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"); var isDevelopment = environment == Environments.Development; if (isDevelopment) { var url = Environment.GetEnvironmentVariable("ASPNETCORE_URLS"); if (string.IsNullOrWhiteSpace(url)) { throw new InvalidOperationException("Application Url must not be empty"); } var uri = new Uri(url); if (!string.Equals(uri.Scheme, "http")) { throw new InvalidOperationException("Application Url must be HTTP in dev mode"); } webBuilder.ConfigureKestrel(options => { options.ListenAnyIP(uri.Port, o => o.Protocols = HttpProtocols.Http2); options.ListenAnyIP(uri.Port * 10, o => o.Protocols = HttpProtocols.Http1); }); } }
public static IWebHost BuildWebHost(string[] args) { IWebHostBuilder webHostBuilder = WebHost.CreateDefaultBuilder(args); webHostBuilder.ConfigureKestrel( options => { options.AddServerHeader = false; //options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(10); }) .ConfigureAppConfiguration(ConfigureAppConfiguration) .CaptureStartupErrors(true) // Add this line to capture startup errors .UseEnvironment(Config.EnvironmentName) //Set the environment name .UseSetting( WebHostDefaults.DetailedErrorsKey, "true") //When enabled (or when the Environment is set to Development), the app captures detailed exceptions. .ConfigureServices( services => services .AddAutofac()); /// This call allows for ConfigureContainer to be supported in Startup with a strongly-typed ContainerBuilder if (!string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("PORT"))) { webHostBuilder.UseUrls($"http://0.0.0.0:{Environment.GetEnvironmentVariable("PORT")}/"); } webHostBuilder.UseStartup <Startup>(); SetupSerilogLogger(webHostBuilder); return(webHostBuilder.Build()); }
public static void ConfigureKestrelHost(this IWebHostBuilder builder) { builder.ConfigureKestrel(serverOptions => { serverOptions.Listen(IPAddress.Any, 5050, listenOptions => { listenOptions.UseHttps(); listenOptions.Protocols = HttpProtocols.Http1; }); }); }
protected override void Configure(IWebHostBuilder builder) { builder.ConfigureKestrel(options => { options.Listen(IPAddress.Any, 8443, listenOptions => { listenOptions.Protocols = HttpProtocols.Http2; listenOptions.UseConnectionLogging(); }); }); }
private static void ConfigureInsecureHttp2Listener(IWebHostBuilder webBuilder) { // Makes Grpc.Core client with ChannelCredentials.Insecure work webBuilder.ConfigureKestrel(options => { // This endpoint will use HTTP/2 and HTTPS on port 5001. options.Listen(IPAddress.Any, 5001, listenOptions => { listenOptions.Protocols = HttpProtocols.Http2; }); }); }
/// <summary> /// Configures the Kestrel HTTPS end point. The mechanism is: /// - Get the port from appSettings to allow for easy changing, /// - Get the certificate from the Azure Key Vault to allow for centralisation and sharing /// amongst multiple virtual machines. /// </summary> private static void ConfigureHttps(IWebHostBuilder webBuilder) { webBuilder.ConfigureKestrel(serverOptions => { if (TlsCertificate != null) { serverOptions.ConfigureHttpsDefaults(listenOptions => { listenOptions.ServerCertificate = TlsCertificate; }); } }); }
private static void setting(IWebHostBuilder webBuilder) { string[] urls = { "http://localhost:8080" };//, "https://localhost:8012" }; //讀取設定檔 var configuration = AppSettingsUtility.getInstance().builder.Build(); var str_urls = configuration["server.urls"]; if (!String.IsNullOrWhiteSpace(str_urls)) { urls = str_urls.Split(";"); } Console.WriteLine("urls " + urls[0]); var str_KeepAliveTimeout = configuration["KestrelSetting:KeepAliveTimeout"]; var str_RequestHeadersTimeout = configuration["KestrelSetting:RequestHeadersTimeout"]; //HTTP持久連線的時間。 int keepAliveTimeout; int.TryParse(str_KeepAliveTimeout, out keepAliveTimeout); keepAliveTimeout = (keepAliveTimeout <= 0) ? 2 * 60 : keepAliveTimeout; //Server 處理一個封包最長的時間。 int requestHeadersTimeout = 30; int.TryParse(str_RequestHeadersTimeout, out requestHeadersTimeout); requestHeadersTimeout = (requestHeadersTimeout <= 0) ? 30 : requestHeadersTimeout; System.Console.WriteLine($"keepAliveTimeout:{keepAliveTimeout} / requestHeadersTimeout:{requestHeadersTimeout}"); var runtime = configuration["server.Runtime"]; if (!String.IsNullOrEmpty(runtime) && runtime != "IIS") { webBuilder.ConfigureKestrel(serverOptions => { serverOptions.AddServerHeader = false; serverOptions.Limits.KeepAliveTimeout = TimeSpan.FromSeconds(keepAliveTimeout); serverOptions.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(requestHeadersTimeout); }) .UseUrls(urls) .UseStartup <Startup>(); } else { webBuilder.UseStartup <Startup>() .UseContentRoot(Directory.GetCurrentDirectory()) .UseIISIntegration(); } }
/// <inheritdoc /> protected override void ConfigureWebHost(IWebHostBuilder builder) { base.ConfigureWebHost(builder); builder.ConfigureServices(ConfigureServicesForTests); builder.ConfigureKestrel( (p) => p.ConfigureHttpsDefaults( (r) => r.ServerCertificate = new X509Certificate2("localhost-dev.pfx", "Pa55w0rd!"))); builder.UseUrls(ServerAddress.ToString()); // Allow the tests on the self-hosted server to link accounts via "Amazon" builder.UseSetting("Site:Alexa:RedirectUrls:3", ServerAddress.ToString() + "manage/"); }
/// <inheritdoc /> protected override void ConfigureWebHost(IWebHostBuilder builder) { builder.ConfigureLogging((loggingBuilder) => loggingBuilder.ClearProviders().AddXUnit(this)) .UseSolutionRelativeContentRoot(Path.Combine("src", "AdventOfCode")); builder.ConfigureKestrel( (p) => p.ConfigureHttpsDefaults( (r) => r.ServerCertificate = new X509Certificate2("localhost-dev.pfx", "Pa55w0rd!"))); builder.UseEnvironment(Environments.Production) .UseSolutionRelativeContentRoot(Path.Combine("src", "AdventOfCode.Site")); // Configure the server address for the server to // listen on for HTTPS requests on a dynamic port. builder.UseUrls("https://127.0.0.1:0"); }
public static IWebHostBuilder ConfigureGenericWebHost(this IWebHostBuilder webHostBuilder) { webHostBuilder.ConfigureKestrel((context, serverOptions) => { var kestrelSection = context.Configuration.GetSection("Kestrel"); serverOptions.Configure(kestrelSection); // serverOptions.Listen(IPAddress.Loopback, 50000); // serverOptions.Listen(IPAddress.Loopback, 50001, // listenOptions => // { // listenOptions.UseHttps("testCert.pfx", // "testPassword"); // }); }); return webHostBuilder; }
protected override void ConfigureWebHost(IWebHostBuilder builder) { builder.ConfigureServices( (services) => services.AddSingleton <IHttpMessageHandlerBuilderFilter, HttpRequestInterceptionFilter>( (_) => new HttpRequestInterceptionFilter(Interceptor))); builder.ConfigureAppConfiguration(ConfigureTests) .ConfigureLogging((loggingBuilder) => loggingBuilder.ClearProviders().AddXUnit(this).AddDebug()) .UseContentRoot(GetContentRootPath()); builder.ConfigureKestrel( (kestrelOptions) => kestrelOptions.ConfigureHttpsDefaults( (connectionOptions) => connectionOptions.ServerCertificate = new X509Certificate2("localhost-dev.pfx", "Pa55w0rd!"))); builder.UseUrls(ServerAddress.ToString()); }
public static IWebHostBuilder ConfigureKestrel(this IWebHostBuilder webBuilder) { webBuilder.UseKestrel(); webBuilder.ConfigureKestrel((context, options) => { var ports = new List <int>(); context.Configuration.GetSection("Ports").Bind(ports); IPAddress ip = IPAddress.Parse("0.0.0.0"); foreach (int port in ports) { options.Listen(ip, port); } }); return(webBuilder); }
private static void ConfigureWebHost(IWebHostBuilder builder) { // TODO Transfer to configuration const string HostName = "+"; const int DefaultPort = 20270; UriBuilder uriBuilder = new UriBuilder() { Host = HostName, Port = DefaultPort, Scheme = Uri.UriSchemeHttp }; builder.UseUrls(uriBuilder.ToString()); builder.ConfigureKestrel(options => options.AddServerHeader = false); builder.UseStartup <Startup>(); }
public static IWebHostBuilder ConfigureDynamicTlsWithVault(this IWebHostBuilder builder) { builder.ConfigureServices(services => { services.AddSingleton <IServerCertificateProvider, VaultSharpServerCertificateProvider>(); }); return(builder.ConfigureKestrel(options => { options.Listen(IPAddress.Any, 443, listenOptions => { listenOptions.UseHttps(new HttpsConnectionAdapterOptions() { SslProtocols = System.Security.Authentication.SslProtocols.Tls12, ServerCertificateSelector = options.ApplicationServices.GetService <IServerCertificateProvider>().ServerCertificateSelector, }); }); })); }
/// <summary> /// Configures Kestrel Webserver with SSL certificate stored in KeyVault. /// The usage is intended for containerized apps in public container registries where the certificates should not be a priori installed /// </summary> /// <param name="webHostBuilder">IWebHostBuilder</param> /// <param name="keyVaultName">Optional keyVaultName, otherwise will be retrieved by ENV 'KeyVaultName'</param> /// <param name="certificateName">Optional certificateName, otherwise will be retrieved by ENV 'CertificateName'</param> /// <param name="portNumber">Optional portNumber, otherwise Standard HTTPS 443 will be used</param> /// <param name="azureConnectionString">Optional azureConnectionString, otherwise will be retrieved by ENV 'AzureConnectionString'</param> /// <returns>IWebHostBuilder instance</returns> public static IWebHostBuilder ConfigureKestrelSSLFromKeyVault(this IWebHostBuilder webHostBuilder, string keyVaultName = null, string certificateName = null, int portNumber = 443, string azureConnectionString = null) { var keyVaultClient = PrepareKeyVaultClient(azureConnectionString); LoadValues(ref keyVaultName, ref certificateName); webHostBuilder .ConfigureKestrel((context, options) => { options.Listen( new IPEndPoint(IPAddress.Any, portNumber), listenOptions => { listenOptions.KestrelServerOptions.AddServerHeader = false; listenOptions.UseHttps(DownloadCertificateFromKeyVault(keyVaultClient, keyVaultName, certificateName)); }); }); return(webHostBuilder); }
private static void ConfigureKestrel(IWebHostBuilder webHostBuilder) { webHostBuilder.ConfigureKestrel((ctx, options) => { options.AddServerHeader = false; var config = ctx.Configuration; var useHttps = config.GetValue <bool>("KestrelOptions:UseSsl"); if (!useHttps) { return; } var certificate = config.GetValue <string>("KestrelOptions:Certificate"); var certificatePassword = config.GetValue <string>("KestrelOptions:CertificatePassword"); options.Listen(IPAddress.Any, 443, listenOptions => { listenOptions.UseHttps(certificate, certificatePassword); }); }); }
public static IWebHostBuilder ConfigureHomeCtlHostDefaults(this IWebHostBuilder builder) { var randomizedPort = PortRandomizer.GetRandomPort(); builder.ConfigureKestrel(options => { options.ListenAnyIP(randomizedPort, listenOptions => { listenOptions.Protocols = AspNetCore.Server.Kestrel.Core.HttpProtocols.Http2; }); }); builder.ConfigureServices(svcs => { svcs.Configure <HomeCtl.Host.HostOptions>(options => { options.HostFile = "host.json"; options.HostPort = randomizedPort; }); svcs.AddStartupService <HostRecordsService>(); svcs.AddStartupService <AppHost>(sP => sP.GetRequiredService <IOptions <HomeCtl.Host.HostOptions> >().Value.GetAppHost()); svcs.AddSingleton <EventBus>(); svcs.AddGrpc(); svcs.AddHostedService <HomeCtlHostService>(); svcs.AddSingleton <ApiServer>(); svcs.AddSingleton <EndpointConnectionManager>(); svcs.AddSingleton <IEndpointClientFactory>(sP => new ReuseSingleClientFactory(new System.Net.Http.HttpClient { DefaultRequestVersion = new System.Version(2, 0) })); svcs.AddSingleton <IServerIdentityVerifier, GrpcIdentityVerifier>(); svcs.AddSingleton <IServerLivelinessMonitor, NetworkErrorLivelinessMonitor>(); svcs.AddSingleton <IServerLivelinessMonitor>(sP => new NetworkTimingLivelinessMonitor(sP.GetRequiredService <ApiServer>())); }); return(builder); }
public static void ConfigureWebApplication(IWebHostBuilder cfg) { var port = Environment.GetEnvironmentVariable("SERVICE_PORT") ?? "5000"; var servicePort = int.Parse(port); // Setup a HTTP/2 endpoint without TLS. cfg.ConfigureKestrel(options => { // https://docs.microsoft.com/en-us/aspnet/core/grpc/troubleshoot?view=aspnetcore-5.0#unable-to-start-aspnet-core-grpc-app-on-macos if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { options.ListenLocalhost(servicePort, o => o.Protocols = HttpProtocols.Http2); } else { options.ListenAnyIP(servicePort, o => o.Protocols = HttpProtocols.Http2); } }); cfg.Configure((ctx, app) => { if (ctx.HostingEnvironment.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseRouting(); app.UseEndpoints(endpoints => { endpoints.MapGrpcService <PaycheckService>(); endpoints.MapGet("/", async context => { await context.Response.WriteAsync("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"); }); }); }); }
/// <summary> /// Configures Kestrel options but does not register an IServer. /// </summary> /// <param name="hostBuilder"> /// The <see cref="Microsoft.AspNetCore.Hosting.IWebHostBuilder" /> to configure. /// </param> /// <exception cref="System.ArgumentNullException"> /// Thrown if hostBuilder is null. /// </exception> /// <returns> /// An <see cref="Microsoft.AspNetCore.Hosting.IWebHostBuilder" /> /// that can be used to further configure the WebHost services. /// </returns> public static IWebHostBuilder ConfigureKestrelHost(this IWebHostBuilder hostBuilder) { if (hostBuilder == null) { throw new ArgumentNullException(paramName: nameof(hostBuilder)); } hostBuilder.ConfigureKestrel(options: serverOptions => { serverOptions.Limits.MaxConcurrentConnections = 100; serverOptions.Limits.MaxConcurrentUpgradedConnections = 100; serverOptions.Limits.MaxRequestBodySize = 10 * 1024; serverOptions.Limits.MinRequestBodyDataRate = CreateMinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(value: 10)); serverOptions.Limits.MinResponseDataRate = CreateMinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(value: 10)); serverOptions.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(value: 2); serverOptions.Limits.RequestHeadersTimeout = TimeSpan.FromMinutes(value: 1); }); return(hostBuilder); }
public static void ForceHttp2IfNoTls(this IWebHostBuilder webBuilder) { var url = Environment.GetEnvironmentVariable("ASPNETCORE_URLS"); if (string.IsNullOrWhiteSpace(url)) { throw new InvalidOperationException("Application Url must not be empty"); } var uri = new Uri(url); if (string.Equals(uri.Scheme, "https")) { return; } webBuilder.ConfigureKestrel(options => { options.ListenAnyIP(uri.Port, o => o.Protocols = HttpProtocols.Http2); // for metrics options.ListenAnyIP(uri.Port * 10, o => o.Protocols = HttpProtocols.Http1); }); }
public static IWebHostBuilder ConfigureTerraformPlugin(this IWebHostBuilder webBuilder, Action <IServiceCollection, ResourceRegistry> configureRegistry, int port = DefaultPort) { webBuilder.ConfigureKestrel(kestrel => { var debugMode = kestrel.ApplicationServices.GetRequiredService <IOptions <TerraformPluginHostOptions> >().Value.DebugMode; if (debugMode) { kestrel.ListenLocalhost(port, x => x.Protocols = HttpProtocols.Http2); } else { kestrel.ListenLocalhost(port, x => x.UseHttps(x => { var certificate = kestrel.ApplicationServices.GetService <PluginHostCertificate>(); if (certificate == null) { throw new InvalidOperationException("Debug mode is not enabled, but no certificate was found."); } x.ServerCertificate = certificate.Certificate; x.AllowAnyClientCertificate(); })); } }); webBuilder.UseStartup <Startup>(); webBuilder.ConfigureServices(services => { services.AddOptions <TerraformPluginHostOptions>().ValidateDataAnnotations(); var registry = new ResourceRegistry(); services.AddSingleton(registry); configureRegistry(services, registry); }); return(webBuilder); }
public static void Configure(IWebHostBuilder webBuilder) { webBuilder.ConfigureKestrel(options => options.AddServerHeader = false); webBuilder.UseStartup <Startup>(); }
/// <summary> /// Run the application /// </summary> /// <param name="cancelToken">Cancel token</param> /// <returns>Task</returns> public async virtual Task StartAsync(CancellationToken cancelToken) { IWebHostBuilder builder = WebHost.CreateDefaultBuilder(Args); builder.ConfigureLogging(logging => { #if !DEBUG logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Warning); #endif }); Dictionary <string, string> argsDictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); if (Args.Length % 2 != 0) { throw new ArgumentException("Arg count must be even. Use a space in between parameter names and values"); } for (int i = 0; i < Args.Length;) { argsDictionary[Args[i++]] = Args[i++].Trim(); } builder.UseKestrel(c => c.AddServerHeader = false); builder.UseIISIntegration(); builder.UseContentRoot(RootDirectory); builder.UseConfiguration(Configuration); argsDictionary.TryGetValue("--server.urls", out string serverUrl); IConfigurationSection web = Configuration.GetSection("mailDemonWeb"); Authority = web["authority"]; string certPathWeb = web["sslCertificateFile"]; string certPathPrivateWeb = web["sslCertificatePrivateKeyFile"]; SecureString certPasswordWeb = web["sslCertificatePassword"]?.ToSecureString(); if (File.Exists(certPathWeb) && File.Exists(certPathPrivateWeb)) { builder.ConfigureKestrel((opt) => { opt.Listen((serverUrl == null ? System.Net.IPAddress.Any : System.Net.IPAddress.Parse(serverUrl)), 443, listenOptions => { listenOptions.UseHttps((sslOpt) => { sslOpt.ServerCertificateSelector = (ctx, name) => { return(CertificateCache.Instance.LoadSslCertificateAsync(certPathWeb, certPathPrivateWeb, certPasswordWeb).Sync()); }; }); }); }); } else if (serverUrl != null) { builder.UseUrls(serverUrl.Split(',', '|', ';')); } try { host = builder.ConfigureServices(services => { services.AddSingleton <IStartup>(this); }).Build(); } catch (Exception ex) { MailDemonLog.Error(ex); } Recaptcha = new RecaptchaSettings(web["recaptchaSiteKey"], web["recaptchaSecretKey"]); AdminLogin = new KeyValuePair <string, string>(web["adminUser"], web["adminPassword"]); Task runTask = host.RunAsync(CancelToken); // do not return the task until we know we are running, for tests for example, we don't want requests coming // in until everything is setup and listening properly if (!runningEvent.WaitOne(10000)) // if 10 seconds and not running, fail { throw new ApplicationException("Failed to start app " + GetType().Name); } await runTask; }
public static IWebHostBuilder UseAppMetrics(this IWebHostBuilder webHostBuilder) { if (_initialized) { return(webHostBuilder); } webHostBuilder.ConfigureKestrel((context, options) => { options.AllowSynchronousIO = true; }); return(webHostBuilder .ConfigureMetricsWithDefaults((context, builder) => { var metricsOptions = context.Configuration.GetOptions <MetricsOptions>("metrics"); if (!metricsOptions.Enabled) { return; } _initialized = true; builder.Configuration.Configure(cfg => { var tags = metricsOptions.Tags; if (tags == null) { return; } tags.TryGetValue("app", out var app); tags.TryGetValue("env", out var env); tags.TryGetValue("server", out var server); cfg.AddAppTag(string.IsNullOrWhiteSpace(app) ? null : app); cfg.AddEnvTag(string.IsNullOrWhiteSpace(env) ? null : env); cfg.AddServerTag(string.IsNullOrWhiteSpace(server) ? null : server); foreach (var tag in tags) { if (!cfg.GlobalTags.ContainsKey(tag.Key)) { cfg.GlobalTags.Add(tag.Key, tag.Value); } } } ); if (metricsOptions.InfluxEnabled) { builder.Report.ToInfluxDb(o => { o.InfluxDb.Database = metricsOptions.Database; o.InfluxDb.BaseUri = new Uri(metricsOptions.InfluxUrl); o.InfluxDb.CreateDataBaseIfNotExists = true; o.FlushInterval = TimeSpan.FromSeconds(metricsOptions.Interval); }); } }) .UseHealth() .UseHealthEndpoints(opts => { opts.HealthEndpointEnabled = true; opts.PingEndpointEnabled = true; }) .UseMetricsWebTracking() .UseMetrics((context, options) => { var metricsOptions = context.Configuration.GetOptions <MetricsOptions>("metrics"); if (!metricsOptions.Enabled) { return; } if (!metricsOptions.PrometheusEnabled) { return; } options.EndpointOptions = endpointOptions => { endpointOptions.MetricsEndpointOutputFormatter = (metricsOptions.PrometheusFormatter?.ToLowerInvariant() ?? string.Empty) switch { "protobuf" => new MetricsPrometheusProtobufOutputFormatter(), _ => new MetricsPrometheusTextOutputFormatter(), }; }; })); }
public void Configure(IWebHostBuilder builder) { builder.ConfigureAppConfiguration((hostingContext, config) => { var settings = config.Build(); config.AddAzureAppConfiguration(options => { options.Connect(settings["ConnectionStrings:AppConfig"]) // Load configuration values with no label .Select(KeyFilter.Any, LabelFilter.Null) // Override with any configuration values specific to current hosting env .Select(KeyFilter.Any, hostingContext.HostingEnvironment.EnvironmentName) .Select(KeyFilter.Any, "Dev-Certificate") .ConfigureKeyVault(kv => { kv.SetCredential(new DefaultAzureCredential()); }); }); var dict = new Dictionary <string, string> { { "DevAccount_FromLibrary", "DEV_1111111-1111" }, { "ProdAccount_FromLibrary", "PROD_2222222-2222" } }; config.AddInMemoryCollection(dict); }); builder.ConfigureKestrel((hostingContext, serverOptions) => { Configuration = hostingContext.Configuration; //var config = new CertificateConfiguration //{ // UseLocalCertStore = Convert.ToBoolean(Configuration["CertificateConfiguration:UseLocalCertStore"]), // CertificateThumbprint = Configuration["CertificateConfiguration:CertificateThumbprint"], // DevelopmentCertificatePfx = Configuration["CertificateConfiguration:DevelopmentCertificatePfx"], // DevelopmentCertificatePassword = Configuration["CertificateConfiguration:DevelopmentCertificatePassword"], // KeyVaultEndpoint = Configuration["CertificateConfiguration:KeyVaultEndpoint"], // CertificateNameKeyVault = Configuration["CertificateConfiguration:CertificateNameKeyVault"] //}; var certificateKey = Environment.GetEnvironmentVariable("CERTIFICATE_KEY"); serverOptions.ConfigureHttpsDefaults(options => { // read cert secret from app configuration with reference to keyvault var certificateSecret = Configuration[certificateKey]; var secretValue = Convert.FromBase64String(certificateSecret); var certificate = new X509Certificate2(secretValue); options.ServerCertificate = certificate; }); ////var port = int.Parse(Environment.GetEnvironmentVariable("ASPNETCORE_HTTPS_PORT")); //var port = int.Parse(Environment.GetEnvironmentVariable("ASPNETCORE_HTTPS_PORT")); //serverOptions.Listen(IPAddress.IPv6Any, port, listenOptions => //{ // // read cert secret from app configuration with reference to keyvault // var certificateSecret = Configuration[certificateKey]; // var secretValue = Convert.FromBase64String(certificateSecret); // var certificate = new X509Certificate2(secretValue); // listenOptions.UseHttps(certificate); // //var certs = CertificateService.GetCertificates(config).GetAwaiter().GetResult(); // //listenOptions.UseHttps(certs.ActiveCertificate); //}); }); }
/// <summary> /// Configures Kestrel to listen to the port and address specified in the Functions Framework configuration. /// </summary> /// <param name="builder">The web host builder to configure.</param> /// <returns>The original builder, for method chaining.</returns> public static IWebHostBuilder ConfigureKestrelForFunctionsFramework(this IWebHostBuilder builder) => builder.ConfigureKestrel((context, serverOptions) => { var options = FunctionsFrameworkOptions.FromConfiguration(context.Configuration); serverOptions.Listen(options.GetIPAddress(), options.Port); });