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

198

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).

Drew Noakes
fonte
10
examine launchSettings.jsonda Propertiespasta. Você pode alterar a porta no launchUrl.
Oleg
@ Oleg, eu tinha algumas configurações relacionadas ao IIS que sobraram do modelo de projeto do RC1. Eles não tiveram nenhum efeito.
Drew Noakes
Pode-se usar hosting.json(ver a resposta ), que foram utilizados por padrão no RC1 e uma necessidade apenas adicionar .AddJsonFile("hosting.json", optional: true)(ver aqui )
Oleg
1
O uso da pilha de configuração parece realmente muito melhor do que depender de um mecanismo puramente específico do VS (launchSettings.json).
Kévin Chalet
@DrewNoakes: eu anexei minha resposta antiga com a parte 2 ATUALIZADA . Ele descreve algumas variações da alteração da porta e uso padrão hosting.jsonou da linha de comandos para configurar a ligação.
Oleg

Respostas:

245

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();
}
Kévin Chalet
fonte
40
O uso de URLs fixos diretamente no código não é a melhor opção na minha opinião.
Oleg
3
Testei isso e funciona bem, obrigado. @ Oleg, você poderia elaborar uma resposta mostrando qual configuração você precisa? Pode ser bom ter isso em um arquivo de configuração.
Drew Noakes
4
@ Oleg talvez, mas usar UseUrlsé a abordagem recomendada pela equipe do ASP.NET para cenários de hospedagem automática (o valor em si não precisa ser codificado, obviamente). Dito isso, atualizei minha resposta para mencionar como você pode fazer isso usando o construtor de configuração.
Kévin Chalet
1
@ Pinpoint: eu postei a resposta antiga , onde é possível encontrar como alterar a porta usando hosting.json. A única coisa que você precisa fazer é forçar a leitura das informações no RC2 (veja o comunicado ).
Oleg
2
Você precisará do seguinte pacote:using Microsoft.Extensions.Configuration.CommandLine;
Aluno
89

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"
      }
    }
  },
menxina
fonte
3
Obrigado, exatamente o que eu precisava :-) Melhor que UseUrls (). Mais detalhes: docs.microsoft.com/en-us/aspnet/core/fundamentals/servers/…
KTCO
7
Isso realmente funciona com binários gerados por meio dotnet publish.
rsenna
Isso não define a porta em que o Kestrel está associado ao IIS (proxy) e não a porta em que o aplicativo está hospedado no IIS?
user12345
@ user12345 Na hospedagem do IIS, o Kestrel usa ligação de porta dinâmica.
Menxin
1
também funciona com o netcore 3.0 executando a API da exe, brilhante !!!
vidriduch
58

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"
Casey
fonte
3
Obrigado, podemos definir variáveis ​​no prompt de comando do Windows da mesma maneira: set ASPNETCORE_URLS = http: // *: 8080
Pavel Biryukov
1
isso não está funcionando para mim. você tem certeza de que isso foi tudo o que você modificou? Você precisou fazer algo especial nas palavras-chave da sua imagem ou algo com o docker?
Steve
Faz tanto tempo que pode ter mudado, mas se me lembro, era tudo o que precisava fazer.
Casey
no VS Code, você pode adicionar "ASPNETCORE_URLS": "http: // +: 8080" na seção "env" do launch.json, para substituir outras configurações.
Gorlok
31

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();
}
Dennis
fonte
7
Isso não funcionou para mim. server.urls agora são URLs e certifique-se de adicionar a entrada project.json "publishOptions": {"include": ["appsettings.json", "web.config", "wwwroot", "hosting.json"]},
Manish Jain
3
Atualizei sua resposta com a propriedade correta urls- obrigado @ManishJain
TetraDev 29/08
30

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

Aleatória
fonte
1
Também trabalha no appSettings.json?
Paulo
Não, tem que estar dentro [ProjectRoot]/Properties/launchSettings.json, mas o mais bonito é que funciona sem problemas.
Chaim Eliyah
5
Isso é útil apenas durante o desenvolvimento, não funciona com binários. para usar, dotnet runvocê precisa acessar o código fonte.
rsenna
18

Se estiver usando dotnet run

dotnet run --urls="http://localhost:5001"
jabu.hlong
fonte
A resposta perfeita! Funciona na janela de encaixe. Substituído apenas "localhost" por "0.0.0.0"
AndrewPt 30/01
17

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"
oudi
fonte
você pode simplesmente usar 'dotnet run --urls = 0.0.0.0:5001 ' no diretório do projeto
oudi
12

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();
    }
}
R. van Diesen
fonte
5

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.

Mwiza
fonte
5

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

Ernest
fonte
3

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

Md. Rafee
fonte
0

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
Sukesh Chand
fonte