web-dev-qa-db-fra.com

Configurer ASP.NET Core 2.0 Kestrel pour HTTPS

TL; DR Quelle est aujourd'hui la bonne façon de configurer HTTPS avec ASP.NET Core 2.0?

Je voudrais configurer mon projet pour utiliser https et un certificat comme ils l'ont montré à BUILD 2017 . J'ai essayé plusieurs réglages mais rien n'a fonctionné. Après quelques recherches, je suis encore plus confus. Il semble qu'il existe de nombreuses façons de configurer les URL et les ports… J'ai vu appsettings.json, hosting.json, via le code et dans launchsettings.json nous pouvons également définir l'URL et le port.

Existe-t-il une manière "standard" de procéder?

Voici mon appsettings.development.json

{
  "Kestrel": {
    "Endpoints": {
      "Localhost": {
        "Address": "127.0.0.1",
        "Port": "40000"
      },
      "LocalhostWithHttps": {
        "Address": "127.0.0.1",
        "Port": "40001",
        "Certificate": {
          "HTTPS": {
            "Source": "Store",
            "StoreLocation": "LocalMachine",
            "StoreName": "My",
            "Subject": "CN=localhost",
            "AllowInvalid": true
          }
        }
      }
    }
  }
}

Mais il prend toujours l'url et le port de launchsettings.json lorsque je démarre à partir de la ligne de commande avec dotnet run ou lorsque je commence avec le débogueur de Visual Studio.

C'est mon Program.cs et Startup.cs

public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .Build();
}

public class Startup
{
    public IConfiguration Configuration { get; }
    public string Authority { get; set; } = "Authority";
    public string ClientId { get; set; } = "ClientId";

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.Configure<MvcOptions>(options => options.Filters.Add(new RequireHttpsAttribute()));

        JsonConvert.DefaultSettings = () => new JsonSerializerSettings() {
            NullValueHandling = NullValueHandling.Ignore
        };

        services.AddSingleton<IRepository, AzureSqlRepository>(x => new AzureSqlRepository(Configuration.GetConnectionString("DefaultConnection")));
        services.AddSingleton<ISearchSplitService, SearchSplitService>();

        services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
            .AddJwtBearer(options => new JwtBearerOptions {
                Authority = this.Authority,
                Audience = this.ClientId
        });

        services.AddMvc();
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
            app.UseWebpackDevMiddleware(new WebpackDevMiddlewareOptions() { HotModuleReplacement = true, ReactHotModuleReplacement = true, HotModuleReplacementEndpoint = "/dist/__webpack_hmr" });
        }

        app.UseStaticFiles();
        app.UseAuthentication();

        app.UseMvc(routes => {
            routes.MapRoute(
                name: "default",
                template: "{controller=Home}/{id?}");

            routes.MapSpaFallbackRoute(
                name: "spa-fallback",
                defaults: new { controller = "Home", action = "Index" });
        });
    }
}

Comme je l'ai dit, je n'ai pu le faire fonctionner dans aucune constallation. Quelle est aujourd'hui la bonne façon de configurer HTTPS avec ASP.NET Core 2.0?

c#asp.net-coreasp.net-core-2.0kestrel-http-server
18
VSDekar

Malheureusement, le mode de configuration basé sur la configuration de HTTPS qui a été montré dans diverses vidéos ou tutoriels avant le lancement d'ASP.NET Core 2.0 n'a pas été intégré dans la version finale.

Pour 2.0, la seule façon de configurer HTTPS est dans le code, en configurant explicitement les écouteurs Kestrel, comme expliqué dans cette annonce , et en utilisant ListenOptions.UseHttps pour activer HTTPS:

var Host = new WebHostBuilder()
    .UseKestrel(options =>
    {
        options.ListenAnyIP(443, listenOptions => 
        {
            listenOptions.UseHttps("server.pfx", "password");
        });
    })
    .UseStartup<Startup>()
    .Build();

Malheureusement, au moment de la publication, la documentation officielle ne couvrait pas cela correctement et annonçait la manière basée sur la configuration qui n'était pas implémentée. Cela a été corrigé depuis.

À partir d'ASP.NET Core 2.1, la configuration HTTPS basée sur la configuration sera possible, comme promis à l'origine. Cela ressemblera probablement à ceci, comme expliqué par Tratcher sur GitHub :

"Kestrel": {
  "Endpoints": {
    "HTTPS": {
      "Url": "https://*:443",
      "Certificate": {
        "Path": "server.pfx",
        "Password": "password"
      }
    }
  }
}

Dans votre exemple particulier, la configuration basée sur le code ressemblerait à ce qui suit. Notez que si vous ne souhaitez pas utiliser un fichier de certificat , vous devez d'abord récupérer manuellement le certificat dans le magasin de certificats.

.UseKestrel(options =>
{
    // listen for HTTP
    options.ListenLocalhost(40000);

    // retrieve certificate from store
    using (var store = new X509Store(StoreName.My))
    {
        store.Open(OpenFlags.ReadOnly);
        var certs = store.Certificates.Find(X509FindType.FindBySubjectName, 
            "localhost", false);
        if (certs.Count > 0)
        {
            var certificate = certs[0];

            // listen for HTTPS
            options.ListenLocalhost(40001, listenOptions =>
            {
                listenOptions.UseHttps(certificate);
            });
        }
    }
})
30
poke