Come specificare la porta su cui è ospitata un'applicazione ASP.NET Core?

Quando si utilizza WebHostBuilderin un Mainpunto di ingresso, come posso specificare la porta a cui si lega?

Di default usa 5000.

Questa domanda è specifica per la nuova API ASP.NET Core (attualmente in 1.0.0-RC2).

In ASP.NET Core 3.1, ci sono 4 modi principali per specificare una porta personalizzata:

• Utilizzando gli argomenti della riga di comando, avviando l'applicazione .NET con --urls=[url]:

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

• Utilizzando appsettings.json, aggiungendo un Urlsnodo:

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

• Utilizzando le variabili di ambiente, con ASPNETCORE_URLS=http://localhost:5001/.
• Usando UseUrls(), se preferisci farlo a livello di codice:

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/");
            });
}

Oppure, se stai ancora utilizzando il generatore di host Web anziché il generatore di host generico:

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

Puoi inserire la sezione Kestrel nel file aspett di base 2.1+ appsettings.json.

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

Risposta di follow-up per aiutare chiunque lo faccia con l'integrazione della finestra mobile VS. Ho dovuto passare alla porta 8080 per funzionare utilizzando l'ambiente "flessibile" in Google Appengine.

È necessario quanto segue nel Dockerfile:

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

e dovrai anche modificare la porta in docker-compose.yml:

    ports:
      - "8080"

La soluzione alternativa è quella di utilizzare a hosting.jsonnella radice del progetto.

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

E poi dentro 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();
}

Puoi specificare l'URL di hosting senza alcuna modifica alla tua app.

Crea un Properties/launchSettings.jsonfile nella directory del tuo progetto e riempilo con qualcosa del genere:

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

dotnet runil comando dovrebbe scegliere il tuo launchSettings.jsonfile e lo visualizzerà nella 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. 

Maggiori dettagli: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments

Se si utilizza dotnet run

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

Sopra .net core 2.2 il metodo Main support args con 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>();
}

Puoi costruire il tuo progetto e andare a bineseguire il comando in questo modo

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

o con più URL

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

Se ospitato in contenitori docker (versione Linux per me), potresti ricevere un messaggio "Connessione rifiutata". In tal caso è possibile utilizzare l'indirizzo IP 0.0.0.0 che significa "tutti gli indirizzi IP su questa macchina" anziché il loopback localhost per correggere il port forwarding.

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();
    }
}

In alternativa, puoi specificare la porta eseguendo l'app dalla riga di comando.

Esegui semplicemente il comando:

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

Nota: dove 5001 è la porta su cui si desidera eseguire.

Su .Net Core 3.1 basta seguire Microsoft Doc che è abbastanza semplice: kestrel-aspnetcore-3.1

Riassumere:

1. Aggiungi la seguente sezione ConfigureServices a CreateDefaultBuilder su 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. Aggiungi la seguente configurazione di base al appsettings.jsonfile (più opzioni di configurazione nell'articolo di Microsoft):

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

3. Apri CMD o Console nella cartella dei file di pubblicazione / debug / rilascio del progetto ed esegui:

   dotnet YourProject.dll

4. Divertiti a esplorare il tuo sito / api sul tuo http: // localhost: 5002

Vai su properties / launchSettings.json e trova il tuo nome app e sotto questo, trova applicationUrl. vedrai che sta eseguendo localhost: 5000, modificalo come preferisci. e poi esegui dotnet corri ...... evviva

Ho risolto il problema delle porte in Net core 3.1 usando il comando seguente

Nel 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>(); });
}

Puoi accedere all'applicazione usando

http://localhost:4000

https://localhost:4001