Como especificar a porta em que um aplicativo ASP.NET Core está hospedado?

Ao usar WebHostBuilderem um Mainponto de entrada, como posso especificar a porta à qual ele se liga?

Por padrão, ele usa 5000.

Observe que esta pergunta é específica para a nova API do ASP.NET Core (atualmente em 1.0.0-RC2).

No ASP.NET Core 3.1, existem 4 maneiras principais de especificar uma porta personalizada:

• Usando argumentos de linha de comando, iniciando seu aplicativo .NET com --urls=[url]:

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

• Usando appsettings.json, adicionando um Urlsnó:

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

• Usando variáveis ​​de ambiente, com ASPNETCORE_URLS=http://localhost:5001/.
• Usando UseUrls(), se você preferir fazê-lo programaticamente:

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, se você ainda estiver usando o construtor de host da web em vez do construtor de host genérico:

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

Você pode inserir a seção Kestrel no arquivo asp.net core 2.1+ appsettings.json.

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

Resposta de acompanhamento para ajudar qualquer pessoa que faça isso com a integração do docker do VS. Eu precisava mudar para a porta 8080 para executar usando o ambiente "flexível" no google appengine.

Você precisará do seguinte em seu Dockerfile:

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

e você também precisará modificar a porta no docker-compose.yml:

    ports:
      - "8080"

Solução alternativa é usar um hosting.jsonna raiz do projeto.

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

E então em 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();
}

Você pode especificar o URL de hospedagem sem nenhuma alteração no seu aplicativo.

Crie um Properties/launchSettings.jsonarquivo no diretório do projeto e preencha-o com algo como isto:

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

dotnet runO comando deve escolher seu launchSettings.jsonarquivo e exibi-lo no 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. 

Mais detalhes: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments

Se estiver usando dotnet run

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

Acima do .net core 2.2, o método Main support args with 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>();
}

Você pode criar seu projeto e binexecutar um comando como este

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

ou com vários URLs

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

Quando hospedado em contêineres de docker (versão linux para mim), você pode receber uma mensagem 'Conexão recusada'. Nesse caso, você pode usar o endereço IP 0.0.0.0, que significa "todos os endereços IP nesta máquina" em vez do loopback do host local para corrigir o encaminhamento de porta.

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

Como alternativa, você pode especificar a porta executando o aplicativo via linha de comando.

Basta executar o comando:

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

Nota: Onde 5001 é a porta na qual você deseja executar.

No .Net Core 3.1 basta seguir o Microsoft Doc que é bem simples: kestrel-aspnetcore-3.1

Para resumir:

1. Adicione a seção ConfigureServices abaixo ao CreateDefaultBuilder em 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. Adicione a configuração básica abaixo ao appsettings.jsonarquivo (mais opções de configuração no artigo da Microsoft):

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

3. Abra o CMD ou o console na pasta de binários de publicação / depuração / lançamento do projeto e execute:

   dotnet YourProject.dll

4. Desfrute de explorar seu site / API no seu http: // localhost: 5002

Vá para properties / launchSettings.json e localize seu nome de aplicativo e, abaixo disso, localize applicationUrl. você verá, ele está executando o localhost: 5000, altere-o para o que quiser. e então execute dotnet run ...... hurra

Corrigi o problema da porta no Net core 3.1 usando o seguinte

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

Você pode acessar o aplicativo usando

http://localhost:4000

https://localhost:4001