Comment spécifier le port sur lequel une application ASP.NET Core est hébergée?

Lors de l'utilisation WebHostBuilderdans unMain point d'entrée, comment puis-je spécifier le port auquel il se lie?

Par défaut, il utilise 5000.

Notez que cette question est spécifique à la nouvelle API ASP.NET Core (actuellement en 1.0.0-RC2).

Dans ASP.NET Core 3.1, il existe 4 façons principales de spécifier un port personnalisé:

• À l'aide d'arguments de ligne de commande, en démarrant votre application .NET avec --urls=[url]:

dotnet run --urls=http://localhost:5001/

• Utilisation appsettings.json, en ajoutant un Urlsnœud:

{
  "Urls": "http://localhost:5001"
}

• Utilisation de variables d'environnement, avec ASPNETCORE_URLS=http://localhost:5001/.
• En utilisant UseUrls(), si vous préférez le faire par programme:

public static class Program
{
    public static void Main(string[] args) =>
        CreateHostBuilder(args).Build().Run();

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(builder =>
            {
                builder.UseStartup<Startup>();
                builder.UseUrls("http://localhost:5001/");
            });
}

Ou, si vous utilisez toujours le générateur d'hôte Web au lieu du générateur d'hôte générique:

public class Program
{
    public static void Main(string[] args) =>
        new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .UseIISIntegration()
            .UseStartup<Startup>()
            .UseUrls("http://localhost:5001/")
            .Build()
            .Run();
}

Vous pouvez insérer la section Kestrel dans le fichier appsettings.json asp.net core 2.1+.

  "Kestrel": {
    "EndPoints": {
      "Http": {
        "Url": "http://0.0.0.0:5002"
      }
    }
  },

Réponse de suivi pour aider quiconque à faire cela avec l'intégration de VS docker. J'avais besoin de passer au port 8080 pour fonctionner en utilisant l'environnement «flexible» dans google appengine.

Vous aurez besoin des éléments suivants dans votre Dockerfile:

ENV ASPNETCORE_URLS=http://+:8080
EXPOSE 8080

et vous devrez également modifier le port dans docker-compose.yml:

    ports:
      - "8080"

Une solution alternative consiste à utiliser un hosting.jsonà la racine du projet.

{
  "urls": "http://localhost:60000"
}

Et puis dans Program.cs

public static void Main(string[] args)
{
    var config = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("hosting.json", true)
        .Build();

    var host = new WebHostBuilder()
        .UseKestrel(options => options.AddServerHeader = false)
        .UseConfiguration(config)
        .UseContentRoot(Directory.GetCurrentDirectory())
        .UseIISIntegration()
        .UseStartup<Startup>()
        .Build();

    host.Run();
}

Vous pouvez spécifier l'URL d'hébergement sans aucune modification de votre application.

Créez un Properties/launchSettings.jsonfichier dans le répertoire de votre projet et remplissez-le avec quelque chose comme ceci:

{
  "profiles": {
    "MyApp1-Dev": {
        "commandName": "Project",
        "environmentVariables": {
            "ASPNETCORE_ENVIRONMENT": "Development"
        },
        "applicationUrl": "http://localhost:5001/"
    }
  }
}

dotnet runLa commande devrait choisir votre launchSettings.jsonfichier et l'affichera dans la console:

C:\ProjectPath [master ≡]
λ  dotnet run
Using launch settings from C:\ProjectPath\Properties\launchSettings.json...
Hosting environment: Development
Content root path: C:\ProjectPath
Now listening on: http://localhost:5001
Application started. Press Ctrl+C to shut down. 

Plus de détails: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments

Si vous utilisez dotnet run

dotnet run --urls="http://localhost:5001"

Au-dessus de .net core 2.2, la méthode Main support args avec WebHost.CreateDefaultBuilder (args)

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

    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>();
}

Vous pouvez créer votre projet et binexécuter une commande comme celle-ci

dotnet <yours>.dll --urls=http://localhost:5001

ou avec multi-urls

dotnet <yours>.dll --urls="http://localhost:5001,https://localhost:5002"

Lorsqu'il est hébergé dans des conteneurs docker (version linux pour moi), vous pouvez recevoir un message «Connexion refusée». Dans ce cas, vous pouvez utiliser l'adresse IP 0.0.0.0 qui signifie "toutes les adresses IP sur cette machine" au lieu du bouclage localhost pour corriger la redirection de port.

public class Program
{
    public static void Main(string[] args)
    {
        var host = new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .UseIISIntegration()
            .UseStartup<Startup>()
            .UseUrls("http://0.0.0.0:5000/")
            .Build();

        host.Run();
    }
}

Vous pouvez également spécifier le port en exécutant l'application via la ligne de commande.

Exécutez simplement la commande:

dotnet run --server.urls http://localhost:5001

Remarque: où 5001 est le port sur lequel vous souhaitez exécuter.

Sur .Net Core 3.1, suivez simplement Microsoft Doc pour dire que c'est assez simple: kestrel-aspnetcore-3.1

Résumer:

1. Ajoutez la section ConfigureServices ci-dessous à CreateDefaultBuilder sur Program.cs:

   // using Microsoft.Extensions.DependencyInjection;
   
   public static IHostBuilder CreateHostBuilder(string[] args) =>
       Host.CreateDefaultBuilder(args)
           .ConfigureServices((context, services) =>
           {
               services.Configure<KestrelServerOptions>(
                   context.Configuration.GetSection("Kestrel"));
           })
           .ConfigureWebHostDefaults(webBuilder =>
           {
               webBuilder.UseStartup<Startup>();
           });

2. Ajoutez la configuration de base ci-dessous au appsettings.jsonfichier (plus d'options de configuration sur l'article Microsoft):

   "Kestrel": {
       "EndPoints": {
           "Http": {
               "Url": "http://0.0.0.0:5002"
           }
       }
   }

3. Ouvrez CMD ou Console sur votre dossier de projet Publish / Debug / Release binaires et exécutez:

   dotnet YourProject.dll

4. Profitez de l'exploration de votre site / API sur votre http: // localhost: 5002

Accédez à properties / launchSettings.json et recherchez votre nom d'application et sous celui-ci, recherchez applicationUrl. vous verrez, il exécute localhost: 5000, changez-le en ce que vous voulez. puis lancez dotnet run ...... hourra

J'ai résolu le problème de port dans Net core 3.1 en utilisant ce qui suit

Dans le Program.cs

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

    public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args)
        .ConfigureWebHost(x => x.UseUrls("https://localhost:4000", "http://localhost:4001"))
        .ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup<Startup>(); });
}

Vous pouvez accéder à l'application en utilisant

http://localhost:4000

https://localhost:4001