Jak określić port, na którym hostowana jest aplikacja ASP.NET Core?


197

W przypadku korzystania WebHostBuilderz Mainpunktu wejścia, jak mogę określić port, z którym się łączy?

Domyślnie używa 5000.

Uwaga: to pytanie dotyczy nowego interfejsu API platformy ASP.NET Core (obecnie w wersji 1.0.0-RC2).


10
sprawdź launchSettings.jsonz Propertiesfolderu. Możesz zmienić port w launchUrl.
Oleg

@Oleg, pozostało mi trochę ustawień związanych z IIS z szablonu projektu RC1. Nie miały żadnego efektu.
Drew Noakes

Można użyć hosting.json(patrz odpowiedź ), które były domyślnie używane w RC1 i wystarczy tylko dodać .AddJsonFile("hosting.json", optional: true)(patrz tutaj )
Oleg

1
Korzystanie ze stosu konfiguracji wydaje się znacznie lepsze niż poleganie na mechanizmie specyficznym dla VS (launchSettings.json).
Kévin Chalet

@DrewNoakes: Dołączyłem moją starą odpowiedź do części UPDATED 2 . Opisuje pewną odmianę zmiany domyślnego portu i użycia hosting.jsonlub wiersza polecenia do konfigurowania powiązania.
Oleg

Odpowiedzi:


244

W programie ASP.NET Core 3.1 istnieją 4 główne sposoby określania niestandardowego portu:

  • Za pomocą argumentów wiersza polecenia, uruchamiając aplikację .NET za pomocą --urls=[url]:
dotnet run --urls=http://localhost:5001/
  • Używając appsettings.json, dodając Urlswęzeł:
{
  "Urls": "http://localhost:5001"
}
  • Używanie zmiennych środowiskowych za pomocą ASPNETCORE_URLS=http://localhost:5001/.
  • Używanie UseUrls(), jeśli wolisz robić to programowo:
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/");
            });
}

Lub, jeśli nadal używasz konstruktora hostów internetowych zamiast ogólnego konstruktora hostów:

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

40
Zastosowanie stałych adresów URL bezpośrednio w kodzie nie jest moim zdaniem najlepszym wyborem.
Oleg

3
Przetestowałem to i działa dobrze, dzięki. @Oleg, czy mógłbyś udzielić odpowiedzi pokazującej, jakiej konfiguracji potrzebujesz? Warto mieć to w pliku konfiguracyjnym.
Drew Noakes

4
@Oleg może, ale użycie UseUrlsjest podejściem zalecanym przez zespół ASP.NET w przypadku scenariuszy z własnym hostingiem (oczywiście sama wartość nie musi być zakodowana na stałe). Powiedziałem, że zaktualizowałem swoją odpowiedź, aby wspomnieć, jak można to zrobić za pomocą konstruktora konfiguracji.
Kévin Chalet

1
@Pinpoint: zamieściłem starą odpowiedź , w której można znaleźć sposób zmiany portu za pomocą hosting.json. Jedyne, co trzeba zrobić, to wymusić odczytanie informacji w RC2 (patrz ogłoszenie ).
Oleg

2
Będziesz potrzebować następującego pakietu:using Microsoft.Extensions.Configuration.CommandLine;
Uczeń

89

Możesz wstawić sekcję Kestrel do pliku asp.net core 2.1+ appsettings.json.

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

3
Dziękuję, właśnie to, czego potrzebowałem :-) Lepsze niż UseUrls (). Więcej informacji: docs.microsoft.com/en-us/aspnet/core/fundamentals/servers/…
KTCO

7
TO faktycznie działa z plikami binarnymi generowanymi przez dotnet publish.
rsenna

Czy to nie definiuje, że port Kestrel jest powiązany z IIS (proxy), a nie port, na którym aplikacja jest hostowana w IIS?
user12345

@ user12345 W hostingu IIS Kestrel używa dynamicznego wiązania portów.
menxin 30.04.19

1
współpracuje również z Netcore 3.0 z uruchomionym interfejsem WWW od exe, genialny !!!
vidriduch

58

Podążaj za odpowiedzią, aby pomóc każdemu w zrobieniu tego dzięki integracji dokera VS. Musiałem zmienić port 8080, aby uruchomić za pomocą „elastycznego” środowiska w Google Appengine.

W pliku Dockerfile będziesz potrzebować:

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

i musisz również zmodyfikować port w docker-compose.yml:

    ports:
      - "8080"

3
Dzięki, możemy ustawić zmienne w poleceniu Windows promt w ten sam sposób: ustaw ASPNETCORE_URLS = http: // *: 8080
Pavel Biryukov

1
to nie działa dla mnie. czy jesteś pewien, że to wszystko, co zmodyfikowałeś? Czy musiałeś zrobić coś specjalnego z obrazkami lub cokolwiek z dokerem?
Steve

Minęło tak dużo czasu, że mogło się to zmienić, ale jeśli sobie przypomnę, to wszystko, co musiałem zrobić.
Casey

w VS Code możesz dodać „ASPNETCORE_URLS”: „http: // +: 8080” w sekcji „env” pliku launch.json, aby zastąpić inne ustawienia.
gorlok

31

Alternatywnym rozwiązaniem jest użycie hosting.jsonkatalogu głównego projektu.

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

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

7
To nie działało dla mnie. server.urls to teraz adresy URL i upewnij się, że dodajesz wpis do projektu.json „PublishingOptions”: {„include”: [„appsettings.json”, „web.config”, „wwwroot”, „hosting.json”]},
Manish Jain

3
Zaktualizowałem jego odpowiedź poprawną właściwością urls- dzięki @ManishJain
TetraDev

30

Możesz podać adres URL hostingu bez żadnych zmian w swojej aplikacji.

Utwórz Properties/launchSettings.jsonplik w katalogu projektu i wypełnij go czymś takim:

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

dotnet runpolecenie powinno wybrać launchSettings.jsonplik i wyświetlić go w konsoli:

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. 

Więcej informacji: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/environments


1
Pracujesz również w appSettings.json?
Paulo

Nie, musi być [ProjectRoot]/Properties/launchSettings.json, ale piękne jest to, że działa bez żadnych problemów.
Chaim Eliyah,

5
Jest to przydatne tylko podczas programowania, nie działa z plikami binarnymi. w celu korzystania dotnet runpotrzebujesz dostępu do kodu źródłowego.
rsenna

18

Jeśli używasz dotnet run

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

Idealna odpowiedź! Działa w oknie dokowanym. Zamieniono tylko „localhost” na „0.0.0.0”
AndrewPt

17

Powyżej rdzenia .net 2.2 metoda Główna obsługa argumentów z 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>();
}

Możesz zbudować swój projekt i binuruchomić polecenie w ten sposób

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

lub z wieloma adresami URL

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

można proste w użyciu „run DotNet --urls = 0.0.0.0:5001 ” w katalogu projektu
Oudi

12

Podczas hostowania w kontenerach dokerów (dla mnie wersja linux) może pojawić się komunikat „Odmowa połączenia”. W takim przypadku możesz użyć adresu IP 0.0.0.0, co oznacza „wszystkie adresy IP na tym komputerze” zamiast sprzężenia zwrotnego hosta lokalnego, aby naprawić przekierowanie portów.

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

5

Alternatywnie można określić port, uruchamiając aplikację za pomocą wiersza polecenia.

Po prostu uruchom polecenie:

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

Uwaga: gdzie 5001 to port, na którym chcesz uruchomić.


5

W .Net Core 3.1 wystarczy postępować zgodnie z Microsoft Doc, że jest to dość proste: kestrel-aspnetcore-3.1

Podsumowując:

  1. Dodaj poniższą sekcję ConfigureServices do CreateDefaultBuilder na 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. Dodaj poniższą podstawową konfigurację do appsettings.jsonpliku (więcej opcji konfiguracji w artykule Microsoft):

    "Kestrel": {
        "EndPoints": {
            "Http": {
                "Url": "http://0.0.0.0:5002"
            }
        }
    }
  3. Otwórz CMD lub konsolę w swoim folderze binarnym Publikuj / Debuguj / Zwolnij i uruchom:

    dotnet YourProject.dll
  4. Zapraszamy do odkrywania swojej witryny / interfejsu API na stronie http: // localhost: 5002


3

Przejdź do właściwości / launchSettings.json i znajdź swoją nazwę aplikacji, a pod nią znajdź applicationUrl. zobaczysz, działa localhost: 5000, zmień go na cokolwiek chcesz. a następnie uruchomić dotnet run ...... hurra


0

Rozwiązałem problem z portem w Net Core 3.1, używając następujących

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

Możesz uzyskać dostęp do aplikacji za pomocą

http://localhost:4000

https://localhost:4001
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.