À l'aide de appsettings.json pour configurer la Crécerelle d'écoute sur le port Dotnet core 2 extrait 2

Ce que je comprends de la façon correcte de réglage écouter les ports pour les ASP Dotnet Core 2 aperçu 1/2 est par la création d'un faucon Crécerelle dans la section appsettings.json dans le format suivant:

"Kestrel": {
    "EndPoints": { //Could also be Endpoints, it's a bit unclear
        "Http": {
        "Address": "127.0.0.1",
    "Port": 9001 //the port you want Kestrel to run on
},

J'ai essayé de configurer l'exemple d'application sur une machine Debian, mais quand je lance l'application, il écrit que l'application est liste sur le port 5000, le port par défaut..

Je sais que le appsettings.json est de lire, parce que quand j'ai changer le niveau d'enregistrement de la Trace, - je obtenir plus d'informations sur le démarrage, y compris qu'aucun des points de terminaison sont trouvés et l'application va utiliser le standard de 5000 port.

J'ai essayé de chercher sur le réseau de code source sur Github, et je peux trouver une zone où le faucon Crécerelle l'article est lu à partir de la configuration (https://github.com/aspnet/Identity/blob/e38759b8a2de1b7a4a1c19462e40214b43c1cf3b/samples/IdentityOIDCWebApplicationSample/MetaPackage/KestrelServerOptionsSetup.cs), mais comme vous pouvez le voir, il ressemble à l'exemple de projet.

Ce qui me manque, n'est-ce pas le moyen standard pour configurer Kestrel en ASP Dotnet core 2?

InformationsquelleAutor Niklas Gislum | 2017-07-20

.net-core kestrel

9

Soutien pour Kestrel configuration via appsettings.json a été supprimée dans la version 2.0.

Voir cette question commentaire:

kestrel fichier de config de soutien a été coupé à partir de la version 2.0.0. Config valeurs doivent être lus manuellement dans votre code d'initialisation.

Pour contourner ce problème, vous pouvez faire quelque chose comme cela dans le programme.cs:
```
public static IWebHost BuildWebHost(string[] args) =>
 WebHost.CreateDefaultBuilder(args)
 .UseStartup < Startup > ()
 .UseKestrel((hostingContext, options) => 
 { 
  if (hostingContext.HostingEnvironment.IsDevelopment) {
   options.Listen(IPAddress.Loopback, 9001);
   options.Listen(IPAddress.Loopback, 9002, listenOptions => {
    listenOptions.UseHttps("certificate.pfx", "password");
   });
  }

 })
 .Build();
```
- .UseKestrel((hostingContext, options) => { var env = hostingContext.HostingEnvironment; } plus propre que: var env = Environnement.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
- Merci @NetProvoke, ont mis à jour.
- Cela va devenir redondant lorsque 2.1 est sorti comme suuport de Kestrel, via la configuration sera de retour, et HTTPS en développement seront, par défaut, blogs.msdn.microsoft.com/webdev/2018/02/02/....
InformationsquelleAutor marcusturewicz
26

Comme mentionné dans un commentaire sur la accepté de répondre, 2.1 a l'appui de appsettings.json, voir https://blogs.msdn.microsoft.com/webdev/2018/02/02/asp-net-core-2-1-roadmap/#security

Un travail appsettings.json:
```
"Kestrel": {
  "EndPoints": {
  "Http": {
  "Url": "http://localhost:5555"
 }}}
```
C'est pour un Programme.cs à l'aide de (créé par "dotnet nouveau webapi"):
```
WebHost.CreateDefaultBuilder(args)
```
Pertinentes du code source sur github https://github.com/aspnet/MetaPackages/blob/master/src/Microsoft.AspNetCore/WebHost.cs#L163
```
options.Configure(builderContext.Configuration.GetSection("Kestrel"));
```
et https://github.com/aspnet/MetaPackages/blob/master/src/Microsoft.AspNetCore/WebHost.cs#L169
```
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
```
InformationsquelleAutor Konstantin
3

Je suis d'utilisation du Programme.cs et de l'hébergement.json fichier de config de Kestrel. Exemple:
```
var config = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("hosting.json", optional: true, reloadOnChange: true)
                .Build();

var host = new WebHostBuilder()
                .UseConfiguration(config)
                .UseKestrel()
                .UseContentRoot(Directory.GetCurrentDirectory())
                .UseStartup<Startup>();
```
d'hébergement.json:
```
{
  "urls": "http://localhost:4444;http://localhost:4445;"
}
```
C'est exapmle pour la dernière version dotnet de base.
Pour les versions antérieures:
de l'hébergement.json:
```
{
  "server.urls": "http://localhost:4444;http://localhost:4445;"
}
```
- Ce son de la même manière j'ai configuré le Kestrel en core 1.1, et c'est je possible de le faire de cette façon, mais j'ai lu à plusieurs endroits que l'avenir de la façon de faire devrait être en utilisant la Crécerelle section appsettings.json. codingblast.com/asp-net-core-2-preview
- Il est également démontré dans cette vidéo youtu.être/h9hlN0DOKRM
- J'ai vu la vidéo et il avait l'air si simple. J'ai essayé moi-même à l'aide de la même méthode, et je ne peux pas le faire fonctionner non plus. Quelqu'un d'autre avez de la chance avec cette?
- Je suis aussi avoir ce problème avec asp.net core 2.0. Rien que j'ai mis dans appsettings.json est utilisé. Je ne comprends pas parce que appsettings devrait être lu par défaut dans la nouvelle asp.net avec la configuration par défaut du constructeur.
- il est possible d'utiliser appsettings.json, voir ici: stackoverflow.com/questions/46696115/...
InformationsquelleAutor Алексей Сидоров
1

Je sais que c'est un vieux post, mais l'exécution de visual studio avec le faucon crécerelle.

il suffit d'éditer le appsettings.json et ajouter la config comme ceci (testé avec NetCore 2.0 et 2.1)
```
    "profiles" : {
        "Kestrel": {
          "commandName": "Project",
          "launchBrowser": true,
          "applicationUrl": "http://localhost:6969/"
        }
    }
```
InformationsquelleAutor totonho
0

J'ai eu le même problème par lequel mon Kestrel configuration dans appsettings.json n'est pas détectée. De cet article sur la migration de asp.net core 2.0 à 2.1, j'ai mis à jour la ou initier code de devenir comme le ci-dessous, et il a travaillé pour moi.
```
    public static void Main(string[] args)
    {
        CreateWebHostBuilder(args).Build().Run();
    }

    public static IWebHostBuilder CreateWebHostBuilder(string[] args)
    {
        return WebHost.CreateDefaultBuilder(args) 
            .UseStartup<Startup>();
    }
```
InformationsquelleAutor peter

Vous devez vous connecter pour publier un commentaire.